CacheBehavior.h

 
#pragma once
#include <aws/cloudfront/CloudFront_EXPORTS.h>
#include <aws/cloudfront/model/AllowedMethods.h>
#include <aws/cloudfront/model/FunctionAssociations.h>
#include <aws/cloudfront/model/GrpcConfig.h>
#include <aws/cloudfront/model/LambdaFunctionAssociations.h>
#include <aws/cloudfront/model/TrustedKeyGroups.h>
#include <aws/cloudfront/model/TrustedSigners.h>
#include <aws/cloudfront/model/ViewerProtocolPolicy.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 CacheBehavior {
 public:
  AWS_CLOUDFRONT_API CacheBehavior() = default;
  AWS_CLOUDFRONT_API CacheBehavior(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_CLOUDFRONT_API CacheBehavior& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_CLOUDFRONT_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline const Aws::String& GetPathPattern() const { return m_pathPattern; }
  inline bool PathPatternHasBeenSet() const { return m_pathPatternHasBeenSet; }
  template <typename PathPatternT = Aws::String>
  void SetPathPattern(PathPatternT&& value) {
    m_pathPatternHasBeenSet = true;
    m_pathPattern = std::forward<PathPatternT>(value);
  }
  template <typename PathPatternT = Aws::String>
  CacheBehavior& WithPathPattern(PathPatternT&& value) {
    SetPathPattern(std::forward<PathPatternT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetOriginId() const { return m_targetOriginId; }
  inline bool TargetOriginIdHasBeenSet() const { return m_targetOriginIdHasBeenSet; }
  template <typename TargetOriginIdT = Aws::String>
  void SetTargetOriginId(TargetOriginIdT&& value) {
    m_targetOriginIdHasBeenSet = true;
    m_targetOriginId = std::forward<TargetOriginIdT>(value);
  }
  template <typename TargetOriginIdT = Aws::String>
  CacheBehavior& WithTargetOriginId(TargetOriginIdT&& value) {
    SetTargetOriginId(std::forward<TargetOriginIdT>(value));
    return *this;
  }
 
 
  inline const TrustedSigners& GetTrustedSigners() const { return m_trustedSigners; }
  inline bool TrustedSignersHasBeenSet() const { return m_trustedSignersHasBeenSet; }
  template <typename TrustedSignersT = TrustedSigners>
  void SetTrustedSigners(TrustedSignersT&& value) {
    m_trustedSignersHasBeenSet = true;
    m_trustedSigners = std::forward<TrustedSignersT>(value);
  }
  template <typename TrustedSignersT = TrustedSigners>
  CacheBehavior& WithTrustedSigners(TrustedSignersT&& value) {
    SetTrustedSigners(std::forward<TrustedSignersT>(value));
    return *this;
  }
 
 
  inline const TrustedKeyGroups& GetTrustedKeyGroups() const { return m_trustedKeyGroups; }
  inline bool TrustedKeyGroupsHasBeenSet() const { return m_trustedKeyGroupsHasBeenSet; }
  template <typename TrustedKeyGroupsT = TrustedKeyGroups>
  void SetTrustedKeyGroups(TrustedKeyGroupsT&& value) {
    m_trustedKeyGroupsHasBeenSet = true;
    m_trustedKeyGroups = std::forward<TrustedKeyGroupsT>(value);
  }
  template <typename TrustedKeyGroupsT = TrustedKeyGroups>
  CacheBehavior& WithTrustedKeyGroups(TrustedKeyGroupsT&& value) {
    SetTrustedKeyGroups(std::forward<TrustedKeyGroupsT>(value));
    return *this;
  }
 
 
  inline ViewerProtocolPolicy GetViewerProtocolPolicy() const { return m_viewerProtocolPolicy; }
  inline bool ViewerProtocolPolicyHasBeenSet() const { return m_viewerProtocolPolicyHasBeenSet; }
  inline void SetViewerProtocolPolicy(ViewerProtocolPolicy value) {
    m_viewerProtocolPolicyHasBeenSet = true;
    m_viewerProtocolPolicy = value;
  }
  inline CacheBehavior& WithViewerProtocolPolicy(ViewerProtocolPolicy value) {
    SetViewerProtocolPolicy(value);
    return *this;
  }
 
 
  inline const AllowedMethods& GetAllowedMethods() const { return m_allowedMethods; }
  inline bool AllowedMethodsHasBeenSet() const { return m_allowedMethodsHasBeenSet; }
  template <typename AllowedMethodsT = AllowedMethods>
  void SetAllowedMethods(AllowedMethodsT&& value) {
    m_allowedMethodsHasBeenSet = true;
    m_allowedMethods = std::forward<AllowedMethodsT>(value);
  }
  template <typename AllowedMethodsT = AllowedMethods>
  CacheBehavior& WithAllowedMethods(AllowedMethodsT&& value) {
    SetAllowedMethods(std::forward<AllowedMethodsT>(value));
    return *this;
  }
 
 
  inline bool GetSmoothStreaming() const { return m_smoothStreaming; }
  inline bool SmoothStreamingHasBeenSet() const { return m_smoothStreamingHasBeenSet; }
  inline void SetSmoothStreaming(bool value) {
    m_smoothStreamingHasBeenSet = true;
    m_smoothStreaming = value;
  }
  inline CacheBehavior& WithSmoothStreaming(bool value) {
    SetSmoothStreaming(value);
    return *this;
  }
 
 
  inline bool GetCompress() const { return m_compress; }
  inline bool CompressHasBeenSet() const { return m_compressHasBeenSet; }
  inline void SetCompress(bool value) {
    m_compressHasBeenSet = true;
    m_compress = value;
  }
  inline CacheBehavior& WithCompress(bool value) {
    SetCompress(value);
    return *this;
  }
 
 
  inline const LambdaFunctionAssociations& GetLambdaFunctionAssociations() const { return m_lambdaFunctionAssociations; }
  inline bool LambdaFunctionAssociationsHasBeenSet() const { return m_lambdaFunctionAssociationsHasBeenSet; }
  template <typename LambdaFunctionAssociationsT = LambdaFunctionAssociations>
  void SetLambdaFunctionAssociations(LambdaFunctionAssociationsT&& value) {
    m_lambdaFunctionAssociationsHasBeenSet = true;
    m_lambdaFunctionAssociations = std::forward<LambdaFunctionAssociationsT>(value);
  }
  template <typename LambdaFunctionAssociationsT = LambdaFunctionAssociations>
  CacheBehavior& WithLambdaFunctionAssociations(LambdaFunctionAssociationsT&& value) {
    SetLambdaFunctionAssociations(std::forward<LambdaFunctionAssociationsT>(value));
    return *this;
  }
 
 
  inline const FunctionAssociations& GetFunctionAssociations() const { return m_functionAssociations; }
  inline bool FunctionAssociationsHasBeenSet() const { return m_functionAssociationsHasBeenSet; }
  template <typename FunctionAssociationsT = FunctionAssociations>
  void SetFunctionAssociations(FunctionAssociationsT&& value) {
    m_functionAssociationsHasBeenSet = true;
    m_functionAssociations = std::forward<FunctionAssociationsT>(value);
  }
  template <typename FunctionAssociationsT = FunctionAssociations>
  CacheBehavior& WithFunctionAssociations(FunctionAssociationsT&& value) {
    SetFunctionAssociations(std::forward<FunctionAssociationsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFieldLevelEncryptionId() const { return m_fieldLevelEncryptionId; }
  inline bool FieldLevelEncryptionIdHasBeenSet() const { return m_fieldLevelEncryptionIdHasBeenSet; }
  template <typename FieldLevelEncryptionIdT = Aws::String>
  void SetFieldLevelEncryptionId(FieldLevelEncryptionIdT&& value) {
    m_fieldLevelEncryptionIdHasBeenSet = true;
    m_fieldLevelEncryptionId = std::forward<FieldLevelEncryptionIdT>(value);
  }
  template <typename FieldLevelEncryptionIdT = Aws::String>
  CacheBehavior& WithFieldLevelEncryptionId(FieldLevelEncryptionIdT&& value) {
    SetFieldLevelEncryptionId(std::forward<FieldLevelEncryptionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRealtimeLogConfigArn() const { return m_realtimeLogConfigArn; }
  inline bool RealtimeLogConfigArnHasBeenSet() const { return m_realtimeLogConfigArnHasBeenSet; }
  template <typename RealtimeLogConfigArnT = Aws::String>
  void SetRealtimeLogConfigArn(RealtimeLogConfigArnT&& value) {
    m_realtimeLogConfigArnHasBeenSet = true;
    m_realtimeLogConfigArn = std::forward<RealtimeLogConfigArnT>(value);
  }
  template <typename RealtimeLogConfigArnT = Aws::String>
  CacheBehavior& WithRealtimeLogConfigArn(RealtimeLogConfigArnT&& value) {
    SetRealtimeLogConfigArn(std::forward<RealtimeLogConfigArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCachePolicyId() const { return m_cachePolicyId; }
  inline bool CachePolicyIdHasBeenSet() const { return m_cachePolicyIdHasBeenSet; }
  template <typename CachePolicyIdT = Aws::String>
  void SetCachePolicyId(CachePolicyIdT&& value) {
    m_cachePolicyIdHasBeenSet = true;
    m_cachePolicyId = std::forward<CachePolicyIdT>(value);
  }
  template <typename CachePolicyIdT = Aws::String>
  CacheBehavior& WithCachePolicyId(CachePolicyIdT&& value) {
    SetCachePolicyId(std::forward<CachePolicyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOriginRequestPolicyId() const { return m_originRequestPolicyId; }
  inline bool OriginRequestPolicyIdHasBeenSet() const { return m_originRequestPolicyIdHasBeenSet; }
  template <typename OriginRequestPolicyIdT = Aws::String>
  void SetOriginRequestPolicyId(OriginRequestPolicyIdT&& value) {
    m_originRequestPolicyIdHasBeenSet = true;
    m_originRequestPolicyId = std::forward<OriginRequestPolicyIdT>(value);
  }
  template <typename OriginRequestPolicyIdT = Aws::String>
  CacheBehavior& WithOriginRequestPolicyId(OriginRequestPolicyIdT&& value) {
    SetOriginRequestPolicyId(std::forward<OriginRequestPolicyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResponseHeadersPolicyId() const { return m_responseHeadersPolicyId; }
  inline bool ResponseHeadersPolicyIdHasBeenSet() const { return m_responseHeadersPolicyIdHasBeenSet; }
  template <typename ResponseHeadersPolicyIdT = Aws::String>
  void SetResponseHeadersPolicyId(ResponseHeadersPolicyIdT&& value) {
    m_responseHeadersPolicyIdHasBeenSet = true;
    m_responseHeadersPolicyId = std::forward<ResponseHeadersPolicyIdT>(value);
  }
  template <typename ResponseHeadersPolicyIdT = Aws::String>
  CacheBehavior& WithResponseHeadersPolicyId(ResponseHeadersPolicyIdT&& value) {
    SetResponseHeadersPolicyId(std::forward<ResponseHeadersPolicyIdT>(value));
    return *this;
  }
 
 
  inline const GrpcConfig& GetGrpcConfig() const { return m_grpcConfig; }
  inline bool GrpcConfigHasBeenSet() const { return m_grpcConfigHasBeenSet; }
  template <typename GrpcConfigT = GrpcConfig>
  void SetGrpcConfig(GrpcConfigT&& value) {
    m_grpcConfigHasBeenSet = true;
    m_grpcConfig = std::forward<GrpcConfigT>(value);
  }
  template <typename GrpcConfigT = GrpcConfig>
  CacheBehavior& WithGrpcConfig(GrpcConfigT&& value) {
    SetGrpcConfig(std::forward<GrpcConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_pathPattern;
 
  Aws::String m_targetOriginId;
 
  TrustedSigners m_trustedSigners;
 
  TrustedKeyGroups m_trustedKeyGroups;
 
  ViewerProtocolPolicy m_viewerProtocolPolicy{ViewerProtocolPolicy::NOT_SET};
 
  AllowedMethods m_allowedMethods;
 
  bool m_smoothStreaming{false};
 
  bool m_compress{false};
 
  LambdaFunctionAssociations m_lambdaFunctionAssociations;
 
  FunctionAssociations m_functionAssociations;
 
  Aws::String m_fieldLevelEncryptionId;
 
  Aws::String m_realtimeLogConfigArn;
 
  Aws::String m_cachePolicyId;
 
  Aws::String m_originRequestPolicyId;
 
  Aws::String m_responseHeadersPolicyId;
 
  GrpcConfig m_grpcConfig;
  bool m_pathPatternHasBeenSet = false;
  bool m_targetOriginIdHasBeenSet = false;
  bool m_trustedSignersHasBeenSet = false;
  bool m_trustedKeyGroupsHasBeenSet = false;
  bool m_viewerProtocolPolicyHasBeenSet = false;
  bool m_allowedMethodsHasBeenSet = false;
  bool m_smoothStreamingHasBeenSet = false;
  bool m_compressHasBeenSet = false;
  bool m_lambdaFunctionAssociationsHasBeenSet = false;
  bool m_functionAssociationsHasBeenSet = false;
  bool m_fieldLevelEncryptionIdHasBeenSet = false;
  bool m_realtimeLogConfigArnHasBeenSet = false;
  bool m_cachePolicyIdHasBeenSet = false;
  bool m_originRequestPolicyIdHasBeenSet = false;
  bool m_responseHeadersPolicyIdHasBeenSet = false;
  bool m_grpcConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CloudFront
}  // namespace Aws