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();
    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; }
    inline void SetIPAddress(const Aws::String& value) { m_iPAddressHasBeenSet = true; m_iPAddress = value; }
    inline void SetIPAddress(Aws::String&& value) { m_iPAddressHasBeenSet = true; m_iPAddress = std::move(value); }
    inline void SetIPAddress(const char* value) { m_iPAddressHasBeenSet = true; m_iPAddress.assign(value); }
    inline HealthCheckConfig& WithIPAddress(const Aws::String& value) { SetIPAddress(value); return *this;}
    inline HealthCheckConfig& WithIPAddress(Aws::String&& value) { SetIPAddress(std::move(value)); return *this;}
    inline HealthCheckConfig& WithIPAddress(const char* value) { SetIPAddress(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 const HealthCheckType& GetType() const{ return m_type; }
    inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
    inline void SetType(const HealthCheckType& value) { m_typeHasBeenSet = true; m_type = value; }
    inline void SetType(HealthCheckType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
    inline HealthCheckConfig& WithType(const HealthCheckType& value) { SetType(value); return *this;}
    inline HealthCheckConfig& WithType(HealthCheckType&& value) { SetType(std::move(value)); return *this;}
 
 
    inline const Aws::String& GetResourcePath() const{ return m_resourcePath; }
    inline bool ResourcePathHasBeenSet() const { return m_resourcePathHasBeenSet; }
    inline void SetResourcePath(const Aws::String& value) { m_resourcePathHasBeenSet = true; m_resourcePath = value; }
    inline void SetResourcePath(Aws::String&& value) { m_resourcePathHasBeenSet = true; m_resourcePath = std::move(value); }
    inline void SetResourcePath(const char* value) { m_resourcePathHasBeenSet = true; m_resourcePath.assign(value); }
    inline HealthCheckConfig& WithResourcePath(const Aws::String& value) { SetResourcePath(value); return *this;}
    inline HealthCheckConfig& WithResourcePath(Aws::String&& value) { SetResourcePath(std::move(value)); return *this;}
    inline HealthCheckConfig& WithResourcePath(const char* value) { SetResourcePath(value); return *this;}
 
 
    inline const Aws::String& GetFullyQualifiedDomainName() const{ return m_fullyQualifiedDomainName; }
    inline bool FullyQualifiedDomainNameHasBeenSet() const { return m_fullyQualifiedDomainNameHasBeenSet; }
    inline void SetFullyQualifiedDomainName(const Aws::String& value) { m_fullyQualifiedDomainNameHasBeenSet = true; m_fullyQualifiedDomainName = value; }
    inline void SetFullyQualifiedDomainName(Aws::String&& value) { m_fullyQualifiedDomainNameHasBeenSet = true; m_fullyQualifiedDomainName = std::move(value); }
    inline void SetFullyQualifiedDomainName(const char* value) { m_fullyQualifiedDomainNameHasBeenSet = true; m_fullyQualifiedDomainName.assign(value); }
    inline HealthCheckConfig& WithFullyQualifiedDomainName(const Aws::String& value) { SetFullyQualifiedDomainName(value); return *this;}
    inline HealthCheckConfig& WithFullyQualifiedDomainName(Aws::String&& value) { SetFullyQualifiedDomainName(std::move(value)); return *this;}
    inline HealthCheckConfig& WithFullyQualifiedDomainName(const char* value) { SetFullyQualifiedDomainName(value); return *this;}
 
 
    inline const Aws::String& GetSearchString() const{ return m_searchString; }
    inline bool SearchStringHasBeenSet() const { return m_searchStringHasBeenSet; }
    inline void SetSearchString(const Aws::String& value) { m_searchStringHasBeenSet = true; m_searchString = value; }
    inline void SetSearchString(Aws::String&& value) { m_searchStringHasBeenSet = true; m_searchString = std::move(value); }
    inline void SetSearchString(const char* value) { m_searchStringHasBeenSet = true; m_searchString.assign(value); }
    inline HealthCheckConfig& WithSearchString(const Aws::String& value) { SetSearchString(value); return *this;}
    inline HealthCheckConfig& WithSearchString(Aws::String&& value) { SetSearchString(std::move(value)); return *this;}
    inline HealthCheckConfig& WithSearchString(const char* value) { SetSearchString(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; }
    inline void SetChildHealthChecks(const Aws::Vector<Aws::String>& value) { m_childHealthChecksHasBeenSet = true; m_childHealthChecks = value; }
    inline void SetChildHealthChecks(Aws::Vector<Aws::String>&& value) { m_childHealthChecksHasBeenSet = true; m_childHealthChecks = std::move(value); }
    inline HealthCheckConfig& WithChildHealthChecks(const Aws::Vector<Aws::String>& value) { SetChildHealthChecks(value); return *this;}
    inline HealthCheckConfig& WithChildHealthChecks(Aws::Vector<Aws::String>&& value) { SetChildHealthChecks(std::move(value)); return *this;}
    inline HealthCheckConfig& AddChildHealthChecks(const Aws::String& value) { m_childHealthChecksHasBeenSet = true; m_childHealthChecks.push_back(value); return *this; }
    inline HealthCheckConfig& AddChildHealthChecks(Aws::String&& value) { m_childHealthChecksHasBeenSet = true; m_childHealthChecks.push_back(std::move(value)); return *this; }
    inline HealthCheckConfig& AddChildHealthChecks(const char* value) { m_childHealthChecksHasBeenSet = true; m_childHealthChecks.push_back(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; }
    inline void SetRegions(const Aws::Vector<HealthCheckRegion>& value) { m_regionsHasBeenSet = true; m_regions = value; }
    inline void SetRegions(Aws::Vector<HealthCheckRegion>&& value) { m_regionsHasBeenSet = true; m_regions = std::move(value); }
    inline HealthCheckConfig& WithRegions(const Aws::Vector<HealthCheckRegion>& value) { SetRegions(value); return *this;}
    inline HealthCheckConfig& WithRegions(Aws::Vector<HealthCheckRegion>&& value) { SetRegions(std::move(value)); return *this;}
    inline HealthCheckConfig& AddRegions(const HealthCheckRegion& value) { m_regionsHasBeenSet = true; m_regions.push_back(value); return *this; }
    inline HealthCheckConfig& AddRegions(HealthCheckRegion&& value) { m_regionsHasBeenSet = true; m_regions.push_back(std::move(value)); return *this; }
 
 
    inline const AlarmIdentifier& GetAlarmIdentifier() const{ return m_alarmIdentifier; }
    inline bool AlarmIdentifierHasBeenSet() const { return m_alarmIdentifierHasBeenSet; }
    inline void SetAlarmIdentifier(const AlarmIdentifier& value) { m_alarmIdentifierHasBeenSet = true; m_alarmIdentifier = value; }
    inline void SetAlarmIdentifier(AlarmIdentifier&& value) { m_alarmIdentifierHasBeenSet = true; m_alarmIdentifier = std::move(value); }
    inline HealthCheckConfig& WithAlarmIdentifier(const AlarmIdentifier& value) { SetAlarmIdentifier(value); return *this;}
    inline HealthCheckConfig& WithAlarmIdentifier(AlarmIdentifier&& value) { SetAlarmIdentifier(std::move(value)); return *this;}
 
 
    inline const InsufficientDataHealthStatus& GetInsufficientDataHealthStatus() const{ return m_insufficientDataHealthStatus; }
    inline bool InsufficientDataHealthStatusHasBeenSet() const { return m_insufficientDataHealthStatusHasBeenSet; }
    inline void SetInsufficientDataHealthStatus(const InsufficientDataHealthStatus& value) { m_insufficientDataHealthStatusHasBeenSet = true; m_insufficientDataHealthStatus = value; }
    inline void SetInsufficientDataHealthStatus(InsufficientDataHealthStatus&& value) { m_insufficientDataHealthStatusHasBeenSet = true; m_insufficientDataHealthStatus = std::move(value); }
    inline HealthCheckConfig& WithInsufficientDataHealthStatus(const InsufficientDataHealthStatus& value) { SetInsufficientDataHealthStatus(value); return *this;}
    inline HealthCheckConfig& WithInsufficientDataHealthStatus(InsufficientDataHealthStatus&& value) { SetInsufficientDataHealthStatus(std::move(value)); return *this;}
 
 
    inline const Aws::String& GetRoutingControlArn() const{ return m_routingControlArn; }
    inline bool RoutingControlArnHasBeenSet() const { return m_routingControlArnHasBeenSet; }
    inline void SetRoutingControlArn(const Aws::String& value) { m_routingControlArnHasBeenSet = true; m_routingControlArn = value; }
    inline void SetRoutingControlArn(Aws::String&& value) { m_routingControlArnHasBeenSet = true; m_routingControlArn = std::move(value); }
    inline void SetRoutingControlArn(const char* value) { m_routingControlArnHasBeenSet = true; m_routingControlArn.assign(value); }
    inline HealthCheckConfig& WithRoutingControlArn(const Aws::String& value) { SetRoutingControlArn(value); return *this;}
    inline HealthCheckConfig& WithRoutingControlArn(Aws::String&& value) { SetRoutingControlArn(std::move(value)); return *this;}
    inline HealthCheckConfig& WithRoutingControlArn(const char* value) { SetRoutingControlArn(value); return *this;}
  private:
 
    Aws::String m_iPAddress;
    bool m_iPAddressHasBeenSet = false;
 
    int m_port;
    bool m_portHasBeenSet = false;
 
    HealthCheckType m_type;
    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;
    bool m_requestIntervalHasBeenSet = false;
 
    int m_failureThreshold;
    bool m_failureThresholdHasBeenSet = false;
 
    bool m_measureLatency;
    bool m_measureLatencyHasBeenSet = false;
 
    bool m_inverted;
    bool m_invertedHasBeenSet = false;
 
    bool m_disabled;
    bool m_disabledHasBeenSet = false;
 
    int m_healthThreshold;
    bool m_healthThresholdHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_childHealthChecks;
    bool m_childHealthChecksHasBeenSet = false;
 
    bool m_enableSNI;
    bool m_enableSNIHasBeenSet = false;
 
    Aws::Vector<HealthCheckRegion> m_regions;
    bool m_regionsHasBeenSet = false;
 
    AlarmIdentifier m_alarmIdentifier;
    bool m_alarmIdentifierHasBeenSet = false;
 
    InsufficientDataHealthStatus m_insufficientDataHealthStatus;
    bool m_insufficientDataHealthStatusHasBeenSet = false;
 
    Aws::String m_routingControlArn;
    bool m_routingControlArnHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Route53
} // namespace Aws