RuleCondition.h

 
#pragma once
#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/ElasticLoadBalancingv2_EXPORTS.h>
#include <aws/elasticloadbalancingv2/model/HostHeaderConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/HttpHeaderConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/HttpRequestMethodConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/PathPatternConditionConfig.h>
#include <aws/elasticloadbalancingv2/model/QueryStringConditionConfig.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;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetRegexValues() const { return m_regexValues; }
  inline bool RegexValuesHasBeenSet() const { return m_regexValuesHasBeenSet; }
  template <typename RegexValuesT = Aws::Vector<Aws::String>>
  void SetRegexValues(RegexValuesT&& value) {
    m_regexValuesHasBeenSet = true;
    m_regexValues = std::forward<RegexValuesT>(value);
  }
  template <typename RegexValuesT = Aws::Vector<Aws::String>>
  RuleCondition& WithRegexValues(RegexValuesT&& value) {
    SetRegexValues(std::forward<RegexValuesT>(value));
    return *this;
  }
  template <typename RegexValuesT = Aws::String>
  RuleCondition& AddRegexValues(RegexValuesT&& value) {
    m_regexValuesHasBeenSet = true;
    m_regexValues.emplace_back(std::forward<RegexValuesT>(value));
    return *this;
  }
 private:
  Aws::String m_field;
 
  Aws::Vector<Aws::String> m_values;
 
  HostHeaderConditionConfig m_hostHeaderConfig;
 
  PathPatternConditionConfig m_pathPatternConfig;
 
  HttpHeaderConditionConfig m_httpHeaderConfig;
 
  QueryStringConditionConfig m_queryStringConfig;
 
  HttpRequestMethodConditionConfig m_httpRequestMethodConfig;
 
  SourceIpConditionConfig m_sourceIpConfig;
 
  Aws::Vector<Aws::String> m_regexValues;
  bool m_fieldHasBeenSet = false;
  bool m_valuesHasBeenSet = false;
  bool m_hostHeaderConfigHasBeenSet = false;
  bool m_pathPatternConfigHasBeenSet = false;
  bool m_httpHeaderConfigHasBeenSet = false;
  bool m_queryStringConfigHasBeenSet = false;
  bool m_httpRequestMethodConfigHasBeenSet = false;
  bool m_sourceIpConfigHasBeenSet = false;
  bool m_regexValuesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElasticLoadBalancingv2
}  // namespace Aws