CustomOriginConfig.h

 
#pragma once
#include <aws/cloudfront/CloudFront_EXPORTS.h>
#include <aws/cloudfront/model/IpAddressType.h>
#include <aws/cloudfront/model/OriginMtlsConfig.h>
#include <aws/cloudfront/model/OriginProtocolPolicy.h>
#include <aws/cloudfront/model/OriginSslProtocols.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace CloudFront {
namespace Model {
 
class CustomOriginConfig {
 public:
  AWS_CLOUDFRONT_API CustomOriginConfig() = default;
  AWS_CLOUDFRONT_API CustomOriginConfig(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_CLOUDFRONT_API CustomOriginConfig& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_CLOUDFRONT_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline int GetHTTPPort() const { return m_hTTPPort; }
  inline bool HTTPPortHasBeenSet() const { return m_hTTPPortHasBeenSet; }
  inline void SetHTTPPort(int value) {
    m_hTTPPortHasBeenSet = true;
    m_hTTPPort = value;
  }
  inline CustomOriginConfig& WithHTTPPort(int value) {
    SetHTTPPort(value);
    return *this;
  }
 
 
  inline int GetHTTPSPort() const { return m_hTTPSPort; }
  inline bool HTTPSPortHasBeenSet() const { return m_hTTPSPortHasBeenSet; }
  inline void SetHTTPSPort(int value) {
    m_hTTPSPortHasBeenSet = true;
    m_hTTPSPort = value;
  }
  inline CustomOriginConfig& WithHTTPSPort(int value) {
    SetHTTPSPort(value);
    return *this;
  }
 
 
  inline OriginProtocolPolicy GetOriginProtocolPolicy() const { return m_originProtocolPolicy; }
  inline bool OriginProtocolPolicyHasBeenSet() const { return m_originProtocolPolicyHasBeenSet; }
  inline void SetOriginProtocolPolicy(OriginProtocolPolicy value) {
    m_originProtocolPolicyHasBeenSet = true;
    m_originProtocolPolicy = value;
  }
  inline CustomOriginConfig& WithOriginProtocolPolicy(OriginProtocolPolicy value) {
    SetOriginProtocolPolicy(value);
    return *this;
  }
 
 
  inline const OriginSslProtocols& GetOriginSslProtocols() const { return m_originSslProtocols; }
  inline bool OriginSslProtocolsHasBeenSet() const { return m_originSslProtocolsHasBeenSet; }
  template <typename OriginSslProtocolsT = OriginSslProtocols>
  void SetOriginSslProtocols(OriginSslProtocolsT&& value) {
    m_originSslProtocolsHasBeenSet = true;
    m_originSslProtocols = std::forward<OriginSslProtocolsT>(value);
  }
  template <typename OriginSslProtocolsT = OriginSslProtocols>
  CustomOriginConfig& WithOriginSslProtocols(OriginSslProtocolsT&& value) {
    SetOriginSslProtocols(std::forward<OriginSslProtocolsT>(value));
    return *this;
  }
 
 
  inline int GetOriginReadTimeout() const { return m_originReadTimeout; }
  inline bool OriginReadTimeoutHasBeenSet() const { return m_originReadTimeoutHasBeenSet; }
  inline void SetOriginReadTimeout(int value) {
    m_originReadTimeoutHasBeenSet = true;
    m_originReadTimeout = value;
  }
  inline CustomOriginConfig& WithOriginReadTimeout(int value) {
    SetOriginReadTimeout(value);
    return *this;
  }
 
 
  inline int GetOriginKeepaliveTimeout() const { return m_originKeepaliveTimeout; }
  inline bool OriginKeepaliveTimeoutHasBeenSet() const { return m_originKeepaliveTimeoutHasBeenSet; }
  inline void SetOriginKeepaliveTimeout(int value) {
    m_originKeepaliveTimeoutHasBeenSet = true;
    m_originKeepaliveTimeout = value;
  }
  inline CustomOriginConfig& WithOriginKeepaliveTimeout(int value) {
    SetOriginKeepaliveTimeout(value);
    return *this;
  }
 
 
  inline IpAddressType GetIpAddressType() const { return m_ipAddressType; }
  inline bool IpAddressTypeHasBeenSet() const { return m_ipAddressTypeHasBeenSet; }
  inline void SetIpAddressType(IpAddressType value) {
    m_ipAddressTypeHasBeenSet = true;
    m_ipAddressType = value;
  }
  inline CustomOriginConfig& WithIpAddressType(IpAddressType value) {
    SetIpAddressType(value);
    return *this;
  }
 
 
  inline const OriginMtlsConfig& GetOriginMtlsConfig() const { return m_originMtlsConfig; }
  inline bool OriginMtlsConfigHasBeenSet() const { return m_originMtlsConfigHasBeenSet; }
  template <typename OriginMtlsConfigT = OriginMtlsConfig>
  void SetOriginMtlsConfig(OriginMtlsConfigT&& value) {
    m_originMtlsConfigHasBeenSet = true;
    m_originMtlsConfig = std::forward<OriginMtlsConfigT>(value);
  }
  template <typename OriginMtlsConfigT = OriginMtlsConfig>
  CustomOriginConfig& WithOriginMtlsConfig(OriginMtlsConfigT&& value) {
    SetOriginMtlsConfig(std::forward<OriginMtlsConfigT>(value));
    return *this;
  }
 private:
  int m_hTTPPort{0};
 
  int m_hTTPSPort{0};
 
  OriginProtocolPolicy m_originProtocolPolicy{OriginProtocolPolicy::NOT_SET};
 
  OriginSslProtocols m_originSslProtocols;
 
  int m_originReadTimeout{0};
 
  int m_originKeepaliveTimeout{0};
 
  IpAddressType m_ipAddressType{IpAddressType::NOT_SET};
 
  OriginMtlsConfig m_originMtlsConfig;
  bool m_hTTPPortHasBeenSet = false;
  bool m_hTTPSPortHasBeenSet = false;
  bool m_originProtocolPolicyHasBeenSet = false;
  bool m_originSslProtocolsHasBeenSet = false;
  bool m_originReadTimeoutHasBeenSet = false;
  bool m_originKeepaliveTimeoutHasBeenSet = false;
  bool m_ipAddressTypeHasBeenSet = false;
  bool m_originMtlsConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudFront
}  // namespace Aws