DistributionConfig.h

 
#pragma once
#include <aws/cloudfront/CloudFront_EXPORTS.h>
#include <aws/cloudfront/model/Aliases.h>
#include <aws/cloudfront/model/CacheBehaviors.h>
#include <aws/cloudfront/model/ConnectionFunctionAssociation.h>
#include <aws/cloudfront/model/ConnectionMode.h>
#include <aws/cloudfront/model/CustomErrorResponses.h>
#include <aws/cloudfront/model/DefaultCacheBehavior.h>
#include <aws/cloudfront/model/HttpVersion.h>
#include <aws/cloudfront/model/LoggingConfig.h>
#include <aws/cloudfront/model/OriginGroups.h>
#include <aws/cloudfront/model/Origins.h>
#include <aws/cloudfront/model/PriceClass.h>
#include <aws/cloudfront/model/Restrictions.h>
#include <aws/cloudfront/model/TenantConfig.h>
#include <aws/cloudfront/model/ViewerCertificate.h>
#include <aws/cloudfront/model/ViewerMtlsConfig.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace CloudFront {
namespace Model {
 
class DistributionConfig {
 public:
  AWS_CLOUDFRONT_API DistributionConfig() = default;
  AWS_CLOUDFRONT_API DistributionConfig(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_CLOUDFRONT_API DistributionConfig& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_CLOUDFRONT_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline const Aws::String& GetCallerReference() const { return m_callerReference; }
  inline bool CallerReferenceHasBeenSet() const { return m_callerReferenceHasBeenSet; }
  template <typename CallerReferenceT = Aws::String>
  void SetCallerReference(CallerReferenceT&& value) {
    m_callerReferenceHasBeenSet = true;
    m_callerReference = std::forward<CallerReferenceT>(value);
  }
  template <typename CallerReferenceT = Aws::String>
  DistributionConfig& WithCallerReference(CallerReferenceT&& value) {
    SetCallerReference(std::forward<CallerReferenceT>(value));
    return *this;
  }
 
 
  inline const Aliases& GetAliases() const { return m_aliases; }
  inline bool AliasesHasBeenSet() const { return m_aliasesHasBeenSet; }
  template <typename AliasesT = Aliases>
  void SetAliases(AliasesT&& value) {
    m_aliasesHasBeenSet = true;
    m_aliases = std::forward<AliasesT>(value);
  }
  template <typename AliasesT = Aliases>
  DistributionConfig& WithAliases(AliasesT&& value) {
    SetAliases(std::forward<AliasesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDefaultRootObject() const { return m_defaultRootObject; }
  inline bool DefaultRootObjectHasBeenSet() const { return m_defaultRootObjectHasBeenSet; }
  template <typename DefaultRootObjectT = Aws::String>
  void SetDefaultRootObject(DefaultRootObjectT&& value) {
    m_defaultRootObjectHasBeenSet = true;
    m_defaultRootObject = std::forward<DefaultRootObjectT>(value);
  }
  template <typename DefaultRootObjectT = Aws::String>
  DistributionConfig& WithDefaultRootObject(DefaultRootObjectT&& value) {
    SetDefaultRootObject(std::forward<DefaultRootObjectT>(value));
    return *this;
  }
 
 
  inline const Origins& GetOrigins() const { return m_origins; }
  inline bool OriginsHasBeenSet() const { return m_originsHasBeenSet; }
  template <typename OriginsT = Origins>
  void SetOrigins(OriginsT&& value) {
    m_originsHasBeenSet = true;
    m_origins = std::forward<OriginsT>(value);
  }
  template <typename OriginsT = Origins>
  DistributionConfig& WithOrigins(OriginsT&& value) {
    SetOrigins(std::forward<OriginsT>(value));
    return *this;
  }
 
 
  inline const OriginGroups& GetOriginGroups() const { return m_originGroups; }
  inline bool OriginGroupsHasBeenSet() const { return m_originGroupsHasBeenSet; }
  template <typename OriginGroupsT = OriginGroups>
  void SetOriginGroups(OriginGroupsT&& value) {
    m_originGroupsHasBeenSet = true;
    m_originGroups = std::forward<OriginGroupsT>(value);
  }
  template <typename OriginGroupsT = OriginGroups>
  DistributionConfig& WithOriginGroups(OriginGroupsT&& value) {
    SetOriginGroups(std::forward<OriginGroupsT>(value));
    return *this;
  }
 
 
  inline const DefaultCacheBehavior& GetDefaultCacheBehavior() const { return m_defaultCacheBehavior; }
  inline bool DefaultCacheBehaviorHasBeenSet() const { return m_defaultCacheBehaviorHasBeenSet; }
  template <typename DefaultCacheBehaviorT = DefaultCacheBehavior>
  void SetDefaultCacheBehavior(DefaultCacheBehaviorT&& value) {
    m_defaultCacheBehaviorHasBeenSet = true;
    m_defaultCacheBehavior = std::forward<DefaultCacheBehaviorT>(value);
  }
  template <typename DefaultCacheBehaviorT = DefaultCacheBehavior>
  DistributionConfig& WithDefaultCacheBehavior(DefaultCacheBehaviorT&& value) {
    SetDefaultCacheBehavior(std::forward<DefaultCacheBehaviorT>(value));
    return *this;
  }
 
 
  inline const CacheBehaviors& GetCacheBehaviors() const { return m_cacheBehaviors; }
  inline bool CacheBehaviorsHasBeenSet() const { return m_cacheBehaviorsHasBeenSet; }
  template <typename CacheBehaviorsT = CacheBehaviors>
  void SetCacheBehaviors(CacheBehaviorsT&& value) {
    m_cacheBehaviorsHasBeenSet = true;
    m_cacheBehaviors = std::forward<CacheBehaviorsT>(value);
  }
  template <typename CacheBehaviorsT = CacheBehaviors>
  DistributionConfig& WithCacheBehaviors(CacheBehaviorsT&& value) {
    SetCacheBehaviors(std::forward<CacheBehaviorsT>(value));
    return *this;
  }
 
 
  inline const CustomErrorResponses& GetCustomErrorResponses() const { return m_customErrorResponses; }
  inline bool CustomErrorResponsesHasBeenSet() const { return m_customErrorResponsesHasBeenSet; }
  template <typename CustomErrorResponsesT = CustomErrorResponses>
  void SetCustomErrorResponses(CustomErrorResponsesT&& value) {
    m_customErrorResponsesHasBeenSet = true;
    m_customErrorResponses = std::forward<CustomErrorResponsesT>(value);
  }
  template <typename CustomErrorResponsesT = CustomErrorResponses>
  DistributionConfig& WithCustomErrorResponses(CustomErrorResponsesT&& value) {
    SetCustomErrorResponses(std::forward<CustomErrorResponsesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetComment() const { return m_comment; }
  inline bool CommentHasBeenSet() const { return m_commentHasBeenSet; }
  template <typename CommentT = Aws::String>
  void SetComment(CommentT&& value) {
    m_commentHasBeenSet = true;
    m_comment = std::forward<CommentT>(value);
  }
  template <typename CommentT = Aws::String>
  DistributionConfig& WithComment(CommentT&& value) {
    SetComment(std::forward<CommentT>(value));
    return *this;
  }
 
 
  inline const LoggingConfig& GetLogging() const { return m_logging; }
  inline bool LoggingHasBeenSet() const { return m_loggingHasBeenSet; }
  template <typename LoggingT = LoggingConfig>
  void SetLogging(LoggingT&& value) {
    m_loggingHasBeenSet = true;
    m_logging = std::forward<LoggingT>(value);
  }
  template <typename LoggingT = LoggingConfig>
  DistributionConfig& WithLogging(LoggingT&& value) {
    SetLogging(std::forward<LoggingT>(value));
    return *this;
  }
 
 
  inline PriceClass GetPriceClass() const { return m_priceClass; }
  inline bool PriceClassHasBeenSet() const { return m_priceClassHasBeenSet; }
  inline void SetPriceClass(PriceClass value) {
    m_priceClassHasBeenSet = true;
    m_priceClass = value;
  }
  inline DistributionConfig& WithPriceClass(PriceClass value) {
    SetPriceClass(value);
    return *this;
  }
 
 
  inline bool GetEnabled() const { return m_enabled; }
  inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
  inline void SetEnabled(bool value) {
    m_enabledHasBeenSet = true;
    m_enabled = value;
  }
  inline DistributionConfig& WithEnabled(bool value) {
    SetEnabled(value);
    return *this;
  }
 
 
  inline const ViewerCertificate& GetViewerCertificate() const { return m_viewerCertificate; }
  inline bool ViewerCertificateHasBeenSet() const { return m_viewerCertificateHasBeenSet; }
  template <typename ViewerCertificateT = ViewerCertificate>
  void SetViewerCertificate(ViewerCertificateT&& value) {
    m_viewerCertificateHasBeenSet = true;
    m_viewerCertificate = std::forward<ViewerCertificateT>(value);
  }
  template <typename ViewerCertificateT = ViewerCertificate>
  DistributionConfig& WithViewerCertificate(ViewerCertificateT&& value) {
    SetViewerCertificate(std::forward<ViewerCertificateT>(value));
    return *this;
  }
 
 
  inline const Restrictions& GetRestrictions() const { return m_restrictions; }
  inline bool RestrictionsHasBeenSet() const { return m_restrictionsHasBeenSet; }
  template <typename RestrictionsT = Restrictions>
  void SetRestrictions(RestrictionsT&& value) {
    m_restrictionsHasBeenSet = true;
    m_restrictions = std::forward<RestrictionsT>(value);
  }
  template <typename RestrictionsT = Restrictions>
  DistributionConfig& WithRestrictions(RestrictionsT&& value) {
    SetRestrictions(std::forward<RestrictionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWebACLId() const { return m_webACLId; }
  inline bool WebACLIdHasBeenSet() const { return m_webACLIdHasBeenSet; }
  template <typename WebACLIdT = Aws::String>
  void SetWebACLId(WebACLIdT&& value) {
    m_webACLIdHasBeenSet = true;
    m_webACLId = std::forward<WebACLIdT>(value);
  }
  template <typename WebACLIdT = Aws::String>
  DistributionConfig& WithWebACLId(WebACLIdT&& value) {
    SetWebACLId(std::forward<WebACLIdT>(value));
    return *this;
  }
 
 
  inline HttpVersion GetHttpVersion() const { return m_httpVersion; }
  inline bool HttpVersionHasBeenSet() const { return m_httpVersionHasBeenSet; }
  inline void SetHttpVersion(HttpVersion value) {
    m_httpVersionHasBeenSet = true;
    m_httpVersion = value;
  }
  inline DistributionConfig& WithHttpVersion(HttpVersion value) {
    SetHttpVersion(value);
    return *this;
  }
 
 
  inline bool GetIsIPV6Enabled() const { return m_isIPV6Enabled; }
  inline bool IsIPV6EnabledHasBeenSet() const { return m_isIPV6EnabledHasBeenSet; }
  inline void SetIsIPV6Enabled(bool value) {
    m_isIPV6EnabledHasBeenSet = true;
    m_isIPV6Enabled = value;
  }
  inline DistributionConfig& WithIsIPV6Enabled(bool value) {
    SetIsIPV6Enabled(value);
    return *this;
  }
 
 
  inline const Aws::String& GetContinuousDeploymentPolicyId() const { return m_continuousDeploymentPolicyId; }
  inline bool ContinuousDeploymentPolicyIdHasBeenSet() const { return m_continuousDeploymentPolicyIdHasBeenSet; }
  template <typename ContinuousDeploymentPolicyIdT = Aws::String>
  void SetContinuousDeploymentPolicyId(ContinuousDeploymentPolicyIdT&& value) {
    m_continuousDeploymentPolicyIdHasBeenSet = true;
    m_continuousDeploymentPolicyId = std::forward<ContinuousDeploymentPolicyIdT>(value);
  }
  template <typename ContinuousDeploymentPolicyIdT = Aws::String>
  DistributionConfig& WithContinuousDeploymentPolicyId(ContinuousDeploymentPolicyIdT&& value) {
    SetContinuousDeploymentPolicyId(std::forward<ContinuousDeploymentPolicyIdT>(value));
    return *this;
  }
 
 
  inline bool GetStaging() const { return m_staging; }
  inline bool StagingHasBeenSet() const { return m_stagingHasBeenSet; }
  inline void SetStaging(bool value) {
    m_stagingHasBeenSet = true;
    m_staging = value;
  }
  inline DistributionConfig& WithStaging(bool value) {
    SetStaging(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAnycastIpListId() const { return m_anycastIpListId; }
  inline bool AnycastIpListIdHasBeenSet() const { return m_anycastIpListIdHasBeenSet; }
  template <typename AnycastIpListIdT = Aws::String>
  void SetAnycastIpListId(AnycastIpListIdT&& value) {
    m_anycastIpListIdHasBeenSet = true;
    m_anycastIpListId = std::forward<AnycastIpListIdT>(value);
  }
  template <typename AnycastIpListIdT = Aws::String>
  DistributionConfig& WithAnycastIpListId(AnycastIpListIdT&& value) {
    SetAnycastIpListId(std::forward<AnycastIpListIdT>(value));
    return *this;
  }
 
 
  inline const TenantConfig& GetTenantConfig() const { return m_tenantConfig; }
  inline bool TenantConfigHasBeenSet() const { return m_tenantConfigHasBeenSet; }
  template <typename TenantConfigT = TenantConfig>
  void SetTenantConfig(TenantConfigT&& value) {
    m_tenantConfigHasBeenSet = true;
    m_tenantConfig = std::forward<TenantConfigT>(value);
  }
  template <typename TenantConfigT = TenantConfig>
  DistributionConfig& WithTenantConfig(TenantConfigT&& value) {
    SetTenantConfig(std::forward<TenantConfigT>(value));
    return *this;
  }
 
 
  inline ConnectionMode GetConnectionMode() const { return m_connectionMode; }
  inline bool ConnectionModeHasBeenSet() const { return m_connectionModeHasBeenSet; }
  inline void SetConnectionMode(ConnectionMode value) {
    m_connectionModeHasBeenSet = true;
    m_connectionMode = value;
  }
  inline DistributionConfig& WithConnectionMode(ConnectionMode value) {
    SetConnectionMode(value);
    return *this;
  }
 
 
  inline const ViewerMtlsConfig& GetViewerMtlsConfig() const { return m_viewerMtlsConfig; }
  inline bool ViewerMtlsConfigHasBeenSet() const { return m_viewerMtlsConfigHasBeenSet; }
  template <typename ViewerMtlsConfigT = ViewerMtlsConfig>
  void SetViewerMtlsConfig(ViewerMtlsConfigT&& value) {
    m_viewerMtlsConfigHasBeenSet = true;
    m_viewerMtlsConfig = std::forward<ViewerMtlsConfigT>(value);
  }
  template <typename ViewerMtlsConfigT = ViewerMtlsConfig>
  DistributionConfig& WithViewerMtlsConfig(ViewerMtlsConfigT&& value) {
    SetViewerMtlsConfig(std::forward<ViewerMtlsConfigT>(value));
    return *this;
  }
 
 
  inline const ConnectionFunctionAssociation& GetConnectionFunctionAssociation() const { return m_connectionFunctionAssociation; }
  inline bool ConnectionFunctionAssociationHasBeenSet() const { return m_connectionFunctionAssociationHasBeenSet; }
  template <typename ConnectionFunctionAssociationT = ConnectionFunctionAssociation>
  void SetConnectionFunctionAssociation(ConnectionFunctionAssociationT&& value) {
    m_connectionFunctionAssociationHasBeenSet = true;
    m_connectionFunctionAssociation = std::forward<ConnectionFunctionAssociationT>(value);
  }
  template <typename ConnectionFunctionAssociationT = ConnectionFunctionAssociation>
  DistributionConfig& WithConnectionFunctionAssociation(ConnectionFunctionAssociationT&& value) {
    SetConnectionFunctionAssociation(std::forward<ConnectionFunctionAssociationT>(value));
    return *this;
  }
 private:
  Aws::String m_callerReference;
 
  Aliases m_aliases;
 
  Aws::String m_defaultRootObject;
 
  Origins m_origins;
 
  OriginGroups m_originGroups;
 
  DefaultCacheBehavior m_defaultCacheBehavior;
 
  CacheBehaviors m_cacheBehaviors;
 
  CustomErrorResponses m_customErrorResponses;
 
  Aws::String m_comment;
 
  LoggingConfig m_logging;
 
  PriceClass m_priceClass{PriceClass::NOT_SET};
 
  bool m_enabled{false};
 
  ViewerCertificate m_viewerCertificate;
 
  Restrictions m_restrictions;
 
  Aws::String m_webACLId;
 
  HttpVersion m_httpVersion{HttpVersion::NOT_SET};
 
  bool m_isIPV6Enabled{false};
 
  Aws::String m_continuousDeploymentPolicyId;
 
  bool m_staging{false};
 
  Aws::String m_anycastIpListId;
 
  TenantConfig m_tenantConfig;
 
  ConnectionMode m_connectionMode{ConnectionMode::NOT_SET};
 
  ViewerMtlsConfig m_viewerMtlsConfig;
 
  ConnectionFunctionAssociation m_connectionFunctionAssociation;
  bool m_callerReferenceHasBeenSet = false;
  bool m_aliasesHasBeenSet = false;
  bool m_defaultRootObjectHasBeenSet = false;
  bool m_originsHasBeenSet = false;
  bool m_originGroupsHasBeenSet = false;
  bool m_defaultCacheBehaviorHasBeenSet = false;
  bool m_cacheBehaviorsHasBeenSet = false;
  bool m_customErrorResponsesHasBeenSet = false;
  bool m_commentHasBeenSet = false;
  bool m_loggingHasBeenSet = false;
  bool m_priceClassHasBeenSet = false;
  bool m_enabledHasBeenSet = false;
  bool m_viewerCertificateHasBeenSet = false;
  bool m_restrictionsHasBeenSet = false;
  bool m_webACLIdHasBeenSet = false;
  bool m_httpVersionHasBeenSet = false;
  bool m_isIPV6EnabledHasBeenSet = false;
  bool m_continuousDeploymentPolicyIdHasBeenSet = false;
  bool m_stagingHasBeenSet = false;
  bool m_anycastIpListIdHasBeenSet = false;
  bool m_tenantConfigHasBeenSet = false;
  bool m_connectionModeHasBeenSet = false;
  bool m_viewerMtlsConfigHasBeenSet = false;
  bool m_connectionFunctionAssociationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudFront
}  // namespace Aws