HealthCheckConfig.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/route53/Route53_EXPORTS.h>
#include <aws/route53/model/AlarmIdentifier.h>
#include <aws/route53/model/HealthCheckRegion.h>
#include <aws/route53/model/HealthCheckType.h>
#include <aws/route53/model/InsufficientDataHealthStatus.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace Route53 {
namespace Model {
 
class HealthCheckConfig {
 public:
  AWS_ROUTE53_API HealthCheckConfig() = default;
  AWS_ROUTE53_API HealthCheckConfig(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_ROUTE53_API HealthCheckConfig& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_ROUTE53_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline const Aws::String& GetIPAddress() const { return m_iPAddress; }
  inline bool IPAddressHasBeenSet() const { return m_iPAddressHasBeenSet; }
  template <typename IPAddressT = Aws::String>
  void SetIPAddress(IPAddressT&& value) {
    m_iPAddressHasBeenSet = true;
    m_iPAddress = std::forward<IPAddressT>(value);
  }
  template <typename IPAddressT = Aws::String>
  HealthCheckConfig& WithIPAddress(IPAddressT&& value) {
    SetIPAddress(std::forward<IPAddressT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline HealthCheckConfig& WithPort(int value) {
    SetPort(value);
    return *this;
  }
 
 
  inline HealthCheckType GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(HealthCheckType value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline HealthCheckConfig& WithType(HealthCheckType value) {
    SetType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetResourcePath() const { return m_resourcePath; }
  inline bool ResourcePathHasBeenSet() const { return m_resourcePathHasBeenSet; }
  template <typename ResourcePathT = Aws::String>
  void SetResourcePath(ResourcePathT&& value) {
    m_resourcePathHasBeenSet = true;
    m_resourcePath = std::forward<ResourcePathT>(value);
  }
  template <typename ResourcePathT = Aws::String>
  HealthCheckConfig& WithResourcePath(ResourcePathT&& value) {
    SetResourcePath(std::forward<ResourcePathT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFullyQualifiedDomainName() const { return m_fullyQualifiedDomainName; }
  inline bool FullyQualifiedDomainNameHasBeenSet() const { return m_fullyQualifiedDomainNameHasBeenSet; }
  template <typename FullyQualifiedDomainNameT = Aws::String>
  void SetFullyQualifiedDomainName(FullyQualifiedDomainNameT&& value) {
    m_fullyQualifiedDomainNameHasBeenSet = true;
    m_fullyQualifiedDomainName = std::forward<FullyQualifiedDomainNameT>(value);
  }
  template <typename FullyQualifiedDomainNameT = Aws::String>
  HealthCheckConfig& WithFullyQualifiedDomainName(FullyQualifiedDomainNameT&& value) {
    SetFullyQualifiedDomainName(std::forward<FullyQualifiedDomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSearchString() const { return m_searchString; }
  inline bool SearchStringHasBeenSet() const { return m_searchStringHasBeenSet; }
  template <typename SearchStringT = Aws::String>
  void SetSearchString(SearchStringT&& value) {
    m_searchStringHasBeenSet = true;
    m_searchString = std::forward<SearchStringT>(value);
  }
  template <typename SearchStringT = Aws::String>
  HealthCheckConfig& WithSearchString(SearchStringT&& value) {
    SetSearchString(std::forward<SearchStringT>(value));
    return *this;
  }
 
 
  inline int GetRequestInterval() const { return m_requestInterval; }
  inline bool RequestIntervalHasBeenSet() const { return m_requestIntervalHasBeenSet; }
  inline void SetRequestInterval(int value) {
    m_requestIntervalHasBeenSet = true;
    m_requestInterval = value;
  }
  inline HealthCheckConfig& WithRequestInterval(int value) {
    SetRequestInterval(value);
    return *this;
  }
 
 
  inline int GetFailureThreshold() const { return m_failureThreshold; }
  inline bool FailureThresholdHasBeenSet() const { return m_failureThresholdHasBeenSet; }
  inline void SetFailureThreshold(int value) {
    m_failureThresholdHasBeenSet = true;
    m_failureThreshold = value;
  }
  inline HealthCheckConfig& WithFailureThreshold(int value) {
    SetFailureThreshold(value);
    return *this;
  }
 
 
  inline bool GetMeasureLatency() const { return m_measureLatency; }
  inline bool MeasureLatencyHasBeenSet() const { return m_measureLatencyHasBeenSet; }
  inline void SetMeasureLatency(bool value) {
    m_measureLatencyHasBeenSet = true;
    m_measureLatency = value;
  }
  inline HealthCheckConfig& WithMeasureLatency(bool value) {
    SetMeasureLatency(value);
    return *this;
  }
 
 
  inline bool GetInverted() const { return m_inverted; }
  inline bool InvertedHasBeenSet() const { return m_invertedHasBeenSet; }
  inline void SetInverted(bool value) {
    m_invertedHasBeenSet = true;
    m_inverted = value;
  }
  inline HealthCheckConfig& WithInverted(bool value) {
    SetInverted(value);
    return *this;
  }
 
 
  inline bool GetDisabled() const { return m_disabled; }
  inline bool DisabledHasBeenSet() const { return m_disabledHasBeenSet; }
  inline void SetDisabled(bool value) {
    m_disabledHasBeenSet = true;
    m_disabled = value;
  }
  inline HealthCheckConfig& WithDisabled(bool value) {
    SetDisabled(value);
    return *this;
  }
 
 
  inline int GetHealthThreshold() const { return m_healthThreshold; }
  inline bool HealthThresholdHasBeenSet() const { return m_healthThresholdHasBeenSet; }
  inline void SetHealthThreshold(int value) {
    m_healthThresholdHasBeenSet = true;
    m_healthThreshold = value;
  }
  inline HealthCheckConfig& WithHealthThreshold(int value) {
    SetHealthThreshold(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetChildHealthChecks() const { return m_childHealthChecks; }
  inline bool ChildHealthChecksHasBeenSet() const { return m_childHealthChecksHasBeenSet; }
  template <typename ChildHealthChecksT = Aws::Vector<Aws::String>>
  void SetChildHealthChecks(ChildHealthChecksT&& value) {
    m_childHealthChecksHasBeenSet = true;
    m_childHealthChecks = std::forward<ChildHealthChecksT>(value);
  }
  template <typename ChildHealthChecksT = Aws::Vector<Aws::String>>
  HealthCheckConfig& WithChildHealthChecks(ChildHealthChecksT&& value) {
    SetChildHealthChecks(std::forward<ChildHealthChecksT>(value));
    return *this;
  }
  template <typename ChildHealthChecksT = Aws::String>
  HealthCheckConfig& AddChildHealthChecks(ChildHealthChecksT&& value) {
    m_childHealthChecksHasBeenSet = true;
    m_childHealthChecks.emplace_back(std::forward<ChildHealthChecksT>(value));
    return *this;
  }
 
 
  inline bool GetEnableSNI() const { return m_enableSNI; }
  inline bool EnableSNIHasBeenSet() const { return m_enableSNIHasBeenSet; }
  inline void SetEnableSNI(bool value) {
    m_enableSNIHasBeenSet = true;
    m_enableSNI = value;
  }
  inline HealthCheckConfig& WithEnableSNI(bool value) {
    SetEnableSNI(value);
    return *this;
  }
 
 
  inline const Aws::Vector<HealthCheckRegion>& GetRegions() const { return m_regions; }
  inline bool RegionsHasBeenSet() const { return m_regionsHasBeenSet; }
  template <typename RegionsT = Aws::Vector<HealthCheckRegion>>
  void SetRegions(RegionsT&& value) {
    m_regionsHasBeenSet = true;
    m_regions = std::forward<RegionsT>(value);
  }
  template <typename RegionsT = Aws::Vector<HealthCheckRegion>>
  HealthCheckConfig& WithRegions(RegionsT&& value) {
    SetRegions(std::forward<RegionsT>(value));
    return *this;
  }
  inline HealthCheckConfig& AddRegions(HealthCheckRegion value) {
    m_regionsHasBeenSet = true;
    m_regions.push_back(value);
    return *this;
  }
 
 
  inline const AlarmIdentifier& GetAlarmIdentifier() const { return m_alarmIdentifier; }
  inline bool AlarmIdentifierHasBeenSet() const { return m_alarmIdentifierHasBeenSet; }
  template <typename AlarmIdentifierT = AlarmIdentifier>
  void SetAlarmIdentifier(AlarmIdentifierT&& value) {
    m_alarmIdentifierHasBeenSet = true;
    m_alarmIdentifier = std::forward<AlarmIdentifierT>(value);
  }
  template <typename AlarmIdentifierT = AlarmIdentifier>
  HealthCheckConfig& WithAlarmIdentifier(AlarmIdentifierT&& value) {
    SetAlarmIdentifier(std::forward<AlarmIdentifierT>(value));
    return *this;
  }
 
 
  inline InsufficientDataHealthStatus GetInsufficientDataHealthStatus() const { return m_insufficientDataHealthStatus; }
  inline bool InsufficientDataHealthStatusHasBeenSet() const { return m_insufficientDataHealthStatusHasBeenSet; }
  inline void SetInsufficientDataHealthStatus(InsufficientDataHealthStatus value) {
    m_insufficientDataHealthStatusHasBeenSet = true;
    m_insufficientDataHealthStatus = value;
  }
  inline HealthCheckConfig& WithInsufficientDataHealthStatus(InsufficientDataHealthStatus value) {
    SetInsufficientDataHealthStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRoutingControlArn() const { return m_routingControlArn; }
  inline bool RoutingControlArnHasBeenSet() const { return m_routingControlArnHasBeenSet; }
  template <typename RoutingControlArnT = Aws::String>
  void SetRoutingControlArn(RoutingControlArnT&& value) {
    m_routingControlArnHasBeenSet = true;
    m_routingControlArn = std::forward<RoutingControlArnT>(value);
  }
  template <typename RoutingControlArnT = Aws::String>
  HealthCheckConfig& WithRoutingControlArn(RoutingControlArnT&& value) {
    SetRoutingControlArn(std::forward<RoutingControlArnT>(value));
    return *this;
  }
 private:
  Aws::String m_iPAddress;
 
  int m_port{0};
 
  HealthCheckType m_type{HealthCheckType::NOT_SET};
 
  Aws::String m_resourcePath;
 
  Aws::String m_fullyQualifiedDomainName;
 
  Aws::String m_searchString;
 
  int m_requestInterval{0};
 
  int m_failureThreshold{0};
 
  bool m_measureLatency{false};
 
  bool m_inverted{false};
 
  bool m_disabled{false};
 
  int m_healthThreshold{0};
 
  Aws::Vector<Aws::String> m_childHealthChecks;
 
  bool m_enableSNI{false};
 
  Aws::Vector<HealthCheckRegion> m_regions;
 
  AlarmIdentifier m_alarmIdentifier;
 
  InsufficientDataHealthStatus m_insufficientDataHealthStatus{InsufficientDataHealthStatus::NOT_SET};
 
  Aws::String m_routingControlArn;
  bool m_iPAddressHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_typeHasBeenSet = false;
  bool m_resourcePathHasBeenSet = false;
  bool m_fullyQualifiedDomainNameHasBeenSet = false;
  bool m_searchStringHasBeenSet = false;
  bool m_requestIntervalHasBeenSet = false;
  bool m_failureThresholdHasBeenSet = false;
  bool m_measureLatencyHasBeenSet = false;
  bool m_invertedHasBeenSet = false;
  bool m_disabledHasBeenSet = false;
  bool m_healthThresholdHasBeenSet = false;
  bool m_childHealthChecksHasBeenSet = false;
  bool m_enableSNIHasBeenSet = false;
  bool m_regionsHasBeenSet = false;
  bool m_alarmIdentifierHasBeenSet = false;
  bool m_insufficientDataHealthStatusHasBeenSet = false;
  bool m_routingControlArnHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Route53
}  // namespace Aws