HealthCheckConfig.h

 
#pragma once
#include <aws/route53/Route53_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/route53/model/HealthCheckType.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/route53/model/AlarmIdentifier.h>
#include <aws/route53/model/InsufficientDataHealthStatus.h>
#include <aws/route53/model/HealthCheckRegion.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;
    bool m_iPAddressHasBeenSet = false;
 
    int m_port{0};
    bool m_portHasBeenSet = false;
 
    HealthCheckType m_type{HealthCheckType::NOT_SET};
    bool m_typeHasBeenSet = false;
 
    Aws::String m_resourcePath;
    bool m_resourcePathHasBeenSet = false;
 
    Aws::String m_fullyQualifiedDomainName;
    bool m_fullyQualifiedDomainNameHasBeenSet = false;
 
    Aws::String m_searchString;
    bool m_searchStringHasBeenSet = false;
 
    int m_requestInterval{0};
    bool m_requestIntervalHasBeenSet = false;
 
    int m_failureThreshold{0};
    bool m_failureThresholdHasBeenSet = false;
 
    bool m_measureLatency{false};
    bool m_measureLatencyHasBeenSet = false;
 
    bool m_inverted{false};
    bool m_invertedHasBeenSet = false;
 
    bool m_disabled{false};
    bool m_disabledHasBeenSet = false;
 
    int m_healthThreshold{0};
    bool m_healthThresholdHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_childHealthChecks;
    bool m_childHealthChecksHasBeenSet = false;
 
    bool m_enableSNI{false};
    bool m_enableSNIHasBeenSet = false;
 
    Aws::Vector<HealthCheckRegion> m_regions;
    bool m_regionsHasBeenSet = false;
 
    AlarmIdentifier m_alarmIdentifier;
    bool m_alarmIdentifierHasBeenSet = false;
 
    InsufficientDataHealthStatus m_insufficientDataHealthStatus{InsufficientDataHealthStatus::NOT_SET};
    bool m_insufficientDataHealthStatusHasBeenSet = false;
 
    Aws::String m_routingControlArn;
    bool m_routingControlArnHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Route53
} // namespace Aws