RuleCondition.h

 
#pragma once
#include <aws/elasticloadbalancingv2/ElasticLoadBalancingv2_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticloadbalancingv2/model/HostHeaderConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/PathPatternConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/HttpHeaderConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/QueryStringConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/HttpRequestMethodConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/SourceIpConditionConfig.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Xml
{
  class XmlNode;
} // namespace Xml
} // namespace Utils
namespace ElasticLoadBalancingv2
{
namespace Model
{
 
  class RuleCondition
  {
  public:
    AWS_ELASTICLOADBALANCINGV2_API RuleCondition() = default;
    AWS_ELASTICLOADBALANCINGV2_API RuleCondition(const Aws::Utils::Xml::XmlNode& xmlNode);
    AWS_ELASTICLOADBALANCINGV2_API RuleCondition& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
    AWS_ELASTICLOADBALANCINGV2_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
    AWS_ELASTICLOADBALANCINGV2_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
 
    inline const Aws::String& GetField() const { return m_field; }
    inline bool FieldHasBeenSet() const { return m_fieldHasBeenSet; }
    template<typename FieldT = Aws::String>
    void SetField(FieldT&& value) { m_fieldHasBeenSet = true; m_field = std::forward<FieldT>(value); }
    template<typename FieldT = Aws::String>
    RuleCondition& WithField(FieldT&& value) { SetField(std::forward<FieldT>(value)); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetValues() const { return m_values; }
    inline bool ValuesHasBeenSet() const { return m_valuesHasBeenSet; }
    template<typename ValuesT = Aws::Vector<Aws::String>>
    void SetValues(ValuesT&& value) { m_valuesHasBeenSet = true; m_values = std::forward<ValuesT>(value); }
    template<typename ValuesT = Aws::Vector<Aws::String>>
    RuleCondition& WithValues(ValuesT&& value) { SetValues(std::forward<ValuesT>(value)); return *this;}
    template<typename ValuesT = Aws::String>
    RuleCondition& AddValues(ValuesT&& value) { m_valuesHasBeenSet = true; m_values.emplace_back(std::forward<ValuesT>(value)); return *this; }
 
 
    inline const HostHeaderConditionConfig& GetHostHeaderConfig() const { return m_hostHeaderConfig; }
    inline bool HostHeaderConfigHasBeenSet() const { return m_hostHeaderConfigHasBeenSet; }
    template<typename HostHeaderConfigT = HostHeaderConditionConfig>
    void SetHostHeaderConfig(HostHeaderConfigT&& value) { m_hostHeaderConfigHasBeenSet = true; m_hostHeaderConfig = std::forward<HostHeaderConfigT>(value); }
    template<typename HostHeaderConfigT = HostHeaderConditionConfig>
    RuleCondition& WithHostHeaderConfig(HostHeaderConfigT&& value) { SetHostHeaderConfig(std::forward<HostHeaderConfigT>(value)); return *this;}
 
 
    inline const PathPatternConditionConfig& GetPathPatternConfig() const { return m_pathPatternConfig; }
    inline bool PathPatternConfigHasBeenSet() const { return m_pathPatternConfigHasBeenSet; }
    template<typename PathPatternConfigT = PathPatternConditionConfig>
    void SetPathPatternConfig(PathPatternConfigT&& value) { m_pathPatternConfigHasBeenSet = true; m_pathPatternConfig = std::forward<PathPatternConfigT>(value); }
    template<typename PathPatternConfigT = PathPatternConditionConfig>
    RuleCondition& WithPathPatternConfig(PathPatternConfigT&& value) { SetPathPatternConfig(std::forward<PathPatternConfigT>(value)); return *this;}
 
 
    inline const HttpHeaderConditionConfig& GetHttpHeaderConfig() const { return m_httpHeaderConfig; }
    inline bool HttpHeaderConfigHasBeenSet() const { return m_httpHeaderConfigHasBeenSet; }
    template<typename HttpHeaderConfigT = HttpHeaderConditionConfig>
    void SetHttpHeaderConfig(HttpHeaderConfigT&& value) { m_httpHeaderConfigHasBeenSet = true; m_httpHeaderConfig = std::forward<HttpHeaderConfigT>(value); }
    template<typename HttpHeaderConfigT = HttpHeaderConditionConfig>
    RuleCondition& WithHttpHeaderConfig(HttpHeaderConfigT&& value) { SetHttpHeaderConfig(std::forward<HttpHeaderConfigT>(value)); return *this;}
 
 
    inline const QueryStringConditionConfig& GetQueryStringConfig() const { return m_queryStringConfig; }
    inline bool QueryStringConfigHasBeenSet() const { return m_queryStringConfigHasBeenSet; }
    template<typename QueryStringConfigT = QueryStringConditionConfig>
    void SetQueryStringConfig(QueryStringConfigT&& value) { m_queryStringConfigHasBeenSet = true; m_queryStringConfig = std::forward<QueryStringConfigT>(value); }
    template<typename QueryStringConfigT = QueryStringConditionConfig>
    RuleCondition& WithQueryStringConfig(QueryStringConfigT&& value) { SetQueryStringConfig(std::forward<QueryStringConfigT>(value)); return *this;}
 
 
    inline const HttpRequestMethodConditionConfig& GetHttpRequestMethodConfig() const { return m_httpRequestMethodConfig; }
    inline bool HttpRequestMethodConfigHasBeenSet() const { return m_httpRequestMethodConfigHasBeenSet; }
    template<typename HttpRequestMethodConfigT = HttpRequestMethodConditionConfig>
    void SetHttpRequestMethodConfig(HttpRequestMethodConfigT&& value) { m_httpRequestMethodConfigHasBeenSet = true; m_httpRequestMethodConfig = std::forward<HttpRequestMethodConfigT>(value); }
    template<typename HttpRequestMethodConfigT = HttpRequestMethodConditionConfig>
    RuleCondition& WithHttpRequestMethodConfig(HttpRequestMethodConfigT&& value) { SetHttpRequestMethodConfig(std::forward<HttpRequestMethodConfigT>(value)); return *this;}
 
 
    inline const SourceIpConditionConfig& GetSourceIpConfig() const { return m_sourceIpConfig; }
    inline bool SourceIpConfigHasBeenSet() const { return m_sourceIpConfigHasBeenSet; }
    template<typename SourceIpConfigT = SourceIpConditionConfig>
    void SetSourceIpConfig(SourceIpConfigT&& value) { m_sourceIpConfigHasBeenSet = true; m_sourceIpConfig = std::forward<SourceIpConfigT>(value); }
    template<typename SourceIpConfigT = SourceIpConditionConfig>
    RuleCondition& WithSourceIpConfig(SourceIpConfigT&& value) { SetSourceIpConfig(std::forward<SourceIpConfigT>(value)); return *this;}
  private:
 
    Aws::String m_field;
    bool m_fieldHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_values;
    bool m_valuesHasBeenSet = false;
 
    HostHeaderConditionConfig m_hostHeaderConfig;
    bool m_hostHeaderConfigHasBeenSet = false;
 
    PathPatternConditionConfig m_pathPatternConfig;
    bool m_pathPatternConfigHasBeenSet = false;
 
    HttpHeaderConditionConfig m_httpHeaderConfig;
    bool m_httpHeaderConfigHasBeenSet = false;
 
    QueryStringConditionConfig m_queryStringConfig;
    bool m_queryStringConfigHasBeenSet = false;
 
    HttpRequestMethodConditionConfig m_httpRequestMethodConfig;
    bool m_httpRequestMethodConfigHasBeenSet = false;
 
    SourceIpConditionConfig m_sourceIpConfig;
    bool m_sourceIpConfigHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ElasticLoadBalancingv2
} // namespace Aws