UpdateDistributionRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/lightsail/LightsailRequest.h>
#include <aws/lightsail/Lightsail_EXPORTS.h>
#include <aws/lightsail/model/CacheBehavior.h>
#include <aws/lightsail/model/CacheBehaviorPerPath.h>
#include <aws/lightsail/model/CacheSettings.h>
#include <aws/lightsail/model/InputOrigin.h>
#include <aws/lightsail/model/ViewerMinimumTlsProtocolVersionEnum.h>
 
#include <utility>
 
namespace Aws {
namespace Lightsail {
namespace Model {
 
class UpdateDistributionRequest : public LightsailRequest {
 public:
  AWS_LIGHTSAIL_API UpdateDistributionRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "UpdateDistribution"; }
 
  AWS_LIGHTSAIL_API Aws::String SerializePayload() const override;
 
  AWS_LIGHTSAIL_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetDistributionName() const { return m_distributionName; }
  inline bool DistributionNameHasBeenSet() const { return m_distributionNameHasBeenSet; }
  template <typename DistributionNameT = Aws::String>
  void SetDistributionName(DistributionNameT&& value) {
    m_distributionNameHasBeenSet = true;
    m_distributionName = std::forward<DistributionNameT>(value);
  }
  template <typename DistributionNameT = Aws::String>
  UpdateDistributionRequest& WithDistributionName(DistributionNameT&& value) {
    SetDistributionName(std::forward<DistributionNameT>(value));
    return *this;
  }
 
 
  inline const InputOrigin& GetOrigin() const { return m_origin; }
  inline bool OriginHasBeenSet() const { return m_originHasBeenSet; }
  template <typename OriginT = InputOrigin>
  void SetOrigin(OriginT&& value) {
    m_originHasBeenSet = true;
    m_origin = std::forward<OriginT>(value);
  }
  template <typename OriginT = InputOrigin>
  UpdateDistributionRequest& WithOrigin(OriginT&& value) {
    SetOrigin(std::forward<OriginT>(value));
    return *this;
  }
 
 
  inline const CacheBehavior& GetDefaultCacheBehavior() const { return m_defaultCacheBehavior; }
  inline bool DefaultCacheBehaviorHasBeenSet() const { return m_defaultCacheBehaviorHasBeenSet; }
  template <typename DefaultCacheBehaviorT = CacheBehavior>
  void SetDefaultCacheBehavior(DefaultCacheBehaviorT&& value) {
    m_defaultCacheBehaviorHasBeenSet = true;
    m_defaultCacheBehavior = std::forward<DefaultCacheBehaviorT>(value);
  }
  template <typename DefaultCacheBehaviorT = CacheBehavior>
  UpdateDistributionRequest& WithDefaultCacheBehavior(DefaultCacheBehaviorT&& value) {
    SetDefaultCacheBehavior(std::forward<DefaultCacheBehaviorT>(value));
    return *this;
  }
 
 
  inline const CacheSettings& GetCacheBehaviorSettings() const { return m_cacheBehaviorSettings; }
  inline bool CacheBehaviorSettingsHasBeenSet() const { return m_cacheBehaviorSettingsHasBeenSet; }
  template <typename CacheBehaviorSettingsT = CacheSettings>
  void SetCacheBehaviorSettings(CacheBehaviorSettingsT&& value) {
    m_cacheBehaviorSettingsHasBeenSet = true;
    m_cacheBehaviorSettings = std::forward<CacheBehaviorSettingsT>(value);
  }
  template <typename CacheBehaviorSettingsT = CacheSettings>
  UpdateDistributionRequest& WithCacheBehaviorSettings(CacheBehaviorSettingsT&& value) {
    SetCacheBehaviorSettings(std::forward<CacheBehaviorSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CacheBehaviorPerPath>& GetCacheBehaviors() const { return m_cacheBehaviors; }
  inline bool CacheBehaviorsHasBeenSet() const { return m_cacheBehaviorsHasBeenSet; }
  template <typename CacheBehaviorsT = Aws::Vector<CacheBehaviorPerPath>>
  void SetCacheBehaviors(CacheBehaviorsT&& value) {
    m_cacheBehaviorsHasBeenSet = true;
    m_cacheBehaviors = std::forward<CacheBehaviorsT>(value);
  }
  template <typename CacheBehaviorsT = Aws::Vector<CacheBehaviorPerPath>>
  UpdateDistributionRequest& WithCacheBehaviors(CacheBehaviorsT&& value) {
    SetCacheBehaviors(std::forward<CacheBehaviorsT>(value));
    return *this;
  }
  template <typename CacheBehaviorsT = CacheBehaviorPerPath>
  UpdateDistributionRequest& AddCacheBehaviors(CacheBehaviorsT&& value) {
    m_cacheBehaviorsHasBeenSet = true;
    m_cacheBehaviors.emplace_back(std::forward<CacheBehaviorsT>(value));
    return *this;
  }
 
 
  inline bool GetIsEnabled() const { return m_isEnabled; }
  inline bool IsEnabledHasBeenSet() const { return m_isEnabledHasBeenSet; }
  inline void SetIsEnabled(bool value) {
    m_isEnabledHasBeenSet = true;
    m_isEnabled = value;
  }
  inline UpdateDistributionRequest& WithIsEnabled(bool value) {
    SetIsEnabled(value);
    return *this;
  }
 
 
  inline ViewerMinimumTlsProtocolVersionEnum GetViewerMinimumTlsProtocolVersion() const { return m_viewerMinimumTlsProtocolVersion; }
  inline bool ViewerMinimumTlsProtocolVersionHasBeenSet() const { return m_viewerMinimumTlsProtocolVersionHasBeenSet; }
  inline void SetViewerMinimumTlsProtocolVersion(ViewerMinimumTlsProtocolVersionEnum value) {
    m_viewerMinimumTlsProtocolVersionHasBeenSet = true;
    m_viewerMinimumTlsProtocolVersion = value;
  }
  inline UpdateDistributionRequest& WithViewerMinimumTlsProtocolVersion(ViewerMinimumTlsProtocolVersionEnum value) {
    SetViewerMinimumTlsProtocolVersion(value);
    return *this;
  }
 
 
  inline const Aws::String& GetCertificateName() const { return m_certificateName; }
  inline bool CertificateNameHasBeenSet() const { return m_certificateNameHasBeenSet; }
  template <typename CertificateNameT = Aws::String>
  void SetCertificateName(CertificateNameT&& value) {
    m_certificateNameHasBeenSet = true;
    m_certificateName = std::forward<CertificateNameT>(value);
  }
  template <typename CertificateNameT = Aws::String>
  UpdateDistributionRequest& WithCertificateName(CertificateNameT&& value) {
    SetCertificateName(std::forward<CertificateNameT>(value));
    return *this;
  }
 
 
  inline bool GetUseDefaultCertificate() const { return m_useDefaultCertificate; }
  inline bool UseDefaultCertificateHasBeenSet() const { return m_useDefaultCertificateHasBeenSet; }
  inline void SetUseDefaultCertificate(bool value) {
    m_useDefaultCertificateHasBeenSet = true;
    m_useDefaultCertificate = value;
  }
  inline UpdateDistributionRequest& WithUseDefaultCertificate(bool value) {
    SetUseDefaultCertificate(value);
    return *this;
  }
 private:
  Aws::String m_distributionName;
 
  InputOrigin m_origin;
 
  CacheBehavior m_defaultCacheBehavior;
 
  CacheSettings m_cacheBehaviorSettings;
 
  Aws::Vector<CacheBehaviorPerPath> m_cacheBehaviors;
 
  bool m_isEnabled{false};
 
  ViewerMinimumTlsProtocolVersionEnum m_viewerMinimumTlsProtocolVersion{ViewerMinimumTlsProtocolVersionEnum::NOT_SET};
 
  Aws::String m_certificateName;
 
  bool m_useDefaultCertificate{false};
  bool m_distributionNameHasBeenSet = false;
  bool m_originHasBeenSet = false;
  bool m_defaultCacheBehaviorHasBeenSet = false;
  bool m_cacheBehaviorSettingsHasBeenSet = false;
  bool m_cacheBehaviorsHasBeenSet = false;
  bool m_isEnabledHasBeenSet = false;
  bool m_viewerMinimumTlsProtocolVersionHasBeenSet = false;
  bool m_certificateNameHasBeenSet = false;
  bool m_useDefaultCertificateHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lightsail
}  // namespace Aws