CacheBehavior.h

 
#pragma once
#include <aws/cloudfront/CloudFront_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/cloudfront/model/TrustedSigners.h>
#include <aws/cloudfront/model/TrustedKeyGroups.h>
#include <aws/cloudfront/model/ViewerProtocolPolicy.h>
#include <aws/cloudfront/model/AllowedMethods.h>
#include <aws/cloudfront/model/LambdaFunctionAssociations.h>
#include <aws/cloudfront/model/FunctionAssociations.h>
#include <aws/cloudfront/model/GrpcConfig.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;
    bool m_pathPatternHasBeenSet = false;
 
    Aws::String m_targetOriginId;
    bool m_targetOriginIdHasBeenSet = false;
 
    TrustedSigners m_trustedSigners;
    bool m_trustedSignersHasBeenSet = false;
 
    TrustedKeyGroups m_trustedKeyGroups;
    bool m_trustedKeyGroupsHasBeenSet = false;
 
    ViewerProtocolPolicy m_viewerProtocolPolicy{ViewerProtocolPolicy::NOT_SET};
    bool m_viewerProtocolPolicyHasBeenSet = false;
 
    AllowedMethods m_allowedMethods;
    bool m_allowedMethodsHasBeenSet = false;
 
    bool m_smoothStreaming{false};
    bool m_smoothStreamingHasBeenSet = false;
 
    bool m_compress{false};
    bool m_compressHasBeenSet = false;
 
    LambdaFunctionAssociations m_lambdaFunctionAssociations;
    bool m_lambdaFunctionAssociationsHasBeenSet = false;
 
    FunctionAssociations m_functionAssociations;
    bool m_functionAssociationsHasBeenSet = false;
 
    Aws::String m_fieldLevelEncryptionId;
    bool m_fieldLevelEncryptionIdHasBeenSet = false;
 
    Aws::String m_realtimeLogConfigArn;
    bool m_realtimeLogConfigArnHasBeenSet = false;
 
    Aws::String m_cachePolicyId;
    bool m_cachePolicyIdHasBeenSet = false;
 
    Aws::String m_originRequestPolicyId;
    bool m_originRequestPolicyIdHasBeenSet = false;
 
    Aws::String m_responseHeadersPolicyId;
    bool m_responseHeadersPolicyIdHasBeenSet = false;
 
    GrpcConfig m_grpcConfig;
    bool m_grpcConfigHasBeenSet = false;
  };
 
} // namespace Model
} // namespace CloudFront
} // namespace Aws