Origin.h

 
#pragma once
#include <aws/cloudfront/CloudFront_EXPORTS.h>
#include <aws/cloudfront/model/CustomHeaders.h>
#include <aws/cloudfront/model/CustomOriginConfig.h>
#include <aws/cloudfront/model/OriginShield.h>
#include <aws/cloudfront/model/S3OriginConfig.h>
#include <aws/cloudfront/model/VpcOriginConfig.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 Origin {
 public:
  AWS_CLOUDFRONT_API Origin() = default;
  AWS_CLOUDFRONT_API Origin(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_CLOUDFRONT_API Origin& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_CLOUDFRONT_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  Origin& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDomainName() const { return m_domainName; }
  inline bool DomainNameHasBeenSet() const { return m_domainNameHasBeenSet; }
  template <typename DomainNameT = Aws::String>
  void SetDomainName(DomainNameT&& value) {
    m_domainNameHasBeenSet = true;
    m_domainName = std::forward<DomainNameT>(value);
  }
  template <typename DomainNameT = Aws::String>
  Origin& WithDomainName(DomainNameT&& value) {
    SetDomainName(std::forward<DomainNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOriginPath() const { return m_originPath; }
  inline bool OriginPathHasBeenSet() const { return m_originPathHasBeenSet; }
  template <typename OriginPathT = Aws::String>
  void SetOriginPath(OriginPathT&& value) {
    m_originPathHasBeenSet = true;
    m_originPath = std::forward<OriginPathT>(value);
  }
  template <typename OriginPathT = Aws::String>
  Origin& WithOriginPath(OriginPathT&& value) {
    SetOriginPath(std::forward<OriginPathT>(value));
    return *this;
  }
 
 
  inline const CustomHeaders& GetCustomHeaders() const { return m_customHeaders; }
  inline bool CustomHeadersHasBeenSet() const { return m_customHeadersHasBeenSet; }
  template <typename CustomHeadersT = CustomHeaders>
  void SetCustomHeaders(CustomHeadersT&& value) {
    m_customHeadersHasBeenSet = true;
    m_customHeaders = std::forward<CustomHeadersT>(value);
  }
  template <typename CustomHeadersT = CustomHeaders>
  Origin& WithCustomHeaders(CustomHeadersT&& value) {
    SetCustomHeaders(std::forward<CustomHeadersT>(value));
    return *this;
  }
 
 
  inline const S3OriginConfig& GetS3OriginConfig() const { return m_s3OriginConfig; }
  inline bool S3OriginConfigHasBeenSet() const { return m_s3OriginConfigHasBeenSet; }
  template <typename S3OriginConfigT = S3OriginConfig>
  void SetS3OriginConfig(S3OriginConfigT&& value) {
    m_s3OriginConfigHasBeenSet = true;
    m_s3OriginConfig = std::forward<S3OriginConfigT>(value);
  }
  template <typename S3OriginConfigT = S3OriginConfig>
  Origin& WithS3OriginConfig(S3OriginConfigT&& value) {
    SetS3OriginConfig(std::forward<S3OriginConfigT>(value));
    return *this;
  }
 
 
  inline const CustomOriginConfig& GetCustomOriginConfig() const { return m_customOriginConfig; }
  inline bool CustomOriginConfigHasBeenSet() const { return m_customOriginConfigHasBeenSet; }
  template <typename CustomOriginConfigT = CustomOriginConfig>
  void SetCustomOriginConfig(CustomOriginConfigT&& value) {
    m_customOriginConfigHasBeenSet = true;
    m_customOriginConfig = std::forward<CustomOriginConfigT>(value);
  }
  template <typename CustomOriginConfigT = CustomOriginConfig>
  Origin& WithCustomOriginConfig(CustomOriginConfigT&& value) {
    SetCustomOriginConfig(std::forward<CustomOriginConfigT>(value));
    return *this;
  }
 
 
  inline const VpcOriginConfig& GetVpcOriginConfig() const { return m_vpcOriginConfig; }
  inline bool VpcOriginConfigHasBeenSet() const { return m_vpcOriginConfigHasBeenSet; }
  template <typename VpcOriginConfigT = VpcOriginConfig>
  void SetVpcOriginConfig(VpcOriginConfigT&& value) {
    m_vpcOriginConfigHasBeenSet = true;
    m_vpcOriginConfig = std::forward<VpcOriginConfigT>(value);
  }
  template <typename VpcOriginConfigT = VpcOriginConfig>
  Origin& WithVpcOriginConfig(VpcOriginConfigT&& value) {
    SetVpcOriginConfig(std::forward<VpcOriginConfigT>(value));
    return *this;
  }
 
 
  inline int GetConnectionAttempts() const { return m_connectionAttempts; }
  inline bool ConnectionAttemptsHasBeenSet() const { return m_connectionAttemptsHasBeenSet; }
  inline void SetConnectionAttempts(int value) {
    m_connectionAttemptsHasBeenSet = true;
    m_connectionAttempts = value;
  }
  inline Origin& WithConnectionAttempts(int value) {
    SetConnectionAttempts(value);
    return *this;
  }
 
 
  inline int GetConnectionTimeout() const { return m_connectionTimeout; }
  inline bool ConnectionTimeoutHasBeenSet() const { return m_connectionTimeoutHasBeenSet; }
  inline void SetConnectionTimeout(int value) {
    m_connectionTimeoutHasBeenSet = true;
    m_connectionTimeout = value;
  }
  inline Origin& WithConnectionTimeout(int value) {
    SetConnectionTimeout(value);
    return *this;
  }
 
 
  inline int GetResponseCompletionTimeout() const { return m_responseCompletionTimeout; }
  inline bool ResponseCompletionTimeoutHasBeenSet() const { return m_responseCompletionTimeoutHasBeenSet; }
  inline void SetResponseCompletionTimeout(int value) {
    m_responseCompletionTimeoutHasBeenSet = true;
    m_responseCompletionTimeout = value;
  }
  inline Origin& WithResponseCompletionTimeout(int value) {
    SetResponseCompletionTimeout(value);
    return *this;
  }
 
 
  inline const OriginShield& GetOriginShield() const { return m_originShield; }
  inline bool OriginShieldHasBeenSet() const { return m_originShieldHasBeenSet; }
  template <typename OriginShieldT = OriginShield>
  void SetOriginShield(OriginShieldT&& value) {
    m_originShieldHasBeenSet = true;
    m_originShield = std::forward<OriginShieldT>(value);
  }
  template <typename OriginShieldT = OriginShield>
  Origin& WithOriginShield(OriginShieldT&& value) {
    SetOriginShield(std::forward<OriginShieldT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOriginAccessControlId() const { return m_originAccessControlId; }
  inline bool OriginAccessControlIdHasBeenSet() const { return m_originAccessControlIdHasBeenSet; }
  template <typename OriginAccessControlIdT = Aws::String>
  void SetOriginAccessControlId(OriginAccessControlIdT&& value) {
    m_originAccessControlIdHasBeenSet = true;
    m_originAccessControlId = std::forward<OriginAccessControlIdT>(value);
  }
  template <typename OriginAccessControlIdT = Aws::String>
  Origin& WithOriginAccessControlId(OriginAccessControlIdT&& value) {
    SetOriginAccessControlId(std::forward<OriginAccessControlIdT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::String m_domainName;
 
  Aws::String m_originPath;
 
  CustomHeaders m_customHeaders;
 
  S3OriginConfig m_s3OriginConfig;
 
  CustomOriginConfig m_customOriginConfig;
 
  VpcOriginConfig m_vpcOriginConfig;
 
  int m_connectionAttempts{0};
 
  int m_connectionTimeout{0};
 
  int m_responseCompletionTimeout{0};
 
  OriginShield m_originShield;
 
  Aws::String m_originAccessControlId;
  bool m_idHasBeenSet = false;
  bool m_domainNameHasBeenSet = false;
  bool m_originPathHasBeenSet = false;
  bool m_customHeadersHasBeenSet = false;
  bool m_s3OriginConfigHasBeenSet = false;
  bool m_customOriginConfigHasBeenSet = false;
  bool m_vpcOriginConfigHasBeenSet = false;
  bool m_connectionAttemptsHasBeenSet = false;
  bool m_connectionTimeoutHasBeenSet = false;
  bool m_responseCompletionTimeoutHasBeenSet = false;
  bool m_originShieldHasBeenSet = false;
  bool m_originAccessControlIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudFront
}  // namespace Aws