CacheSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/lightsail/Lightsail_EXPORTS.h>
#include <aws/lightsail/model/CookieObject.h>
#include <aws/lightsail/model/HeaderObject.h>
#include <aws/lightsail/model/QueryStringObject.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Lightsail {
namespace Model {
 
class CacheSettings {
 public:
  AWS_LIGHTSAIL_API CacheSettings() = default;
  AWS_LIGHTSAIL_API CacheSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_LIGHTSAIL_API CacheSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_LIGHTSAIL_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline long long GetDefaultTTL() const { return m_defaultTTL; }
  inline bool DefaultTTLHasBeenSet() const { return m_defaultTTLHasBeenSet; }
  inline void SetDefaultTTL(long long value) {
    m_defaultTTLHasBeenSet = true;
    m_defaultTTL = value;
  }
  inline CacheSettings& WithDefaultTTL(long long value) {
    SetDefaultTTL(value);
    return *this;
  }
 
 
  inline long long GetMinimumTTL() const { return m_minimumTTL; }
  inline bool MinimumTTLHasBeenSet() const { return m_minimumTTLHasBeenSet; }
  inline void SetMinimumTTL(long long value) {
    m_minimumTTLHasBeenSet = true;
    m_minimumTTL = value;
  }
  inline CacheSettings& WithMinimumTTL(long long value) {
    SetMinimumTTL(value);
    return *this;
  }
 
 
  inline long long GetMaximumTTL() const { return m_maximumTTL; }
  inline bool MaximumTTLHasBeenSet() const { return m_maximumTTLHasBeenSet; }
  inline void SetMaximumTTL(long long value) {
    m_maximumTTLHasBeenSet = true;
    m_maximumTTL = value;
  }
  inline CacheSettings& WithMaximumTTL(long long value) {
    SetMaximumTTL(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAllowedHTTPMethods() const { return m_allowedHTTPMethods; }
  inline bool AllowedHTTPMethodsHasBeenSet() const { return m_allowedHTTPMethodsHasBeenSet; }
  template <typename AllowedHTTPMethodsT = Aws::String>
  void SetAllowedHTTPMethods(AllowedHTTPMethodsT&& value) {
    m_allowedHTTPMethodsHasBeenSet = true;
    m_allowedHTTPMethods = std::forward<AllowedHTTPMethodsT>(value);
  }
  template <typename AllowedHTTPMethodsT = Aws::String>
  CacheSettings& WithAllowedHTTPMethods(AllowedHTTPMethodsT&& value) {
    SetAllowedHTTPMethods(std::forward<AllowedHTTPMethodsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCachedHTTPMethods() const { return m_cachedHTTPMethods; }
  inline bool CachedHTTPMethodsHasBeenSet() const { return m_cachedHTTPMethodsHasBeenSet; }
  template <typename CachedHTTPMethodsT = Aws::String>
  void SetCachedHTTPMethods(CachedHTTPMethodsT&& value) {
    m_cachedHTTPMethodsHasBeenSet = true;
    m_cachedHTTPMethods = std::forward<CachedHTTPMethodsT>(value);
  }
  template <typename CachedHTTPMethodsT = Aws::String>
  CacheSettings& WithCachedHTTPMethods(CachedHTTPMethodsT&& value) {
    SetCachedHTTPMethods(std::forward<CachedHTTPMethodsT>(value));
    return *this;
  }
 
 
  inline const CookieObject& GetForwardedCookies() const { return m_forwardedCookies; }
  inline bool ForwardedCookiesHasBeenSet() const { return m_forwardedCookiesHasBeenSet; }
  template <typename ForwardedCookiesT = CookieObject>
  void SetForwardedCookies(ForwardedCookiesT&& value) {
    m_forwardedCookiesHasBeenSet = true;
    m_forwardedCookies = std::forward<ForwardedCookiesT>(value);
  }
  template <typename ForwardedCookiesT = CookieObject>
  CacheSettings& WithForwardedCookies(ForwardedCookiesT&& value) {
    SetForwardedCookies(std::forward<ForwardedCookiesT>(value));
    return *this;
  }
 
 
  inline const HeaderObject& GetForwardedHeaders() const { return m_forwardedHeaders; }
  inline bool ForwardedHeadersHasBeenSet() const { return m_forwardedHeadersHasBeenSet; }
  template <typename ForwardedHeadersT = HeaderObject>
  void SetForwardedHeaders(ForwardedHeadersT&& value) {
    m_forwardedHeadersHasBeenSet = true;
    m_forwardedHeaders = std::forward<ForwardedHeadersT>(value);
  }
  template <typename ForwardedHeadersT = HeaderObject>
  CacheSettings& WithForwardedHeaders(ForwardedHeadersT&& value) {
    SetForwardedHeaders(std::forward<ForwardedHeadersT>(value));
    return *this;
  }
 
 
  inline const QueryStringObject& GetForwardedQueryStrings() const { return m_forwardedQueryStrings; }
  inline bool ForwardedQueryStringsHasBeenSet() const { return m_forwardedQueryStringsHasBeenSet; }
  template <typename ForwardedQueryStringsT = QueryStringObject>
  void SetForwardedQueryStrings(ForwardedQueryStringsT&& value) {
    m_forwardedQueryStringsHasBeenSet = true;
    m_forwardedQueryStrings = std::forward<ForwardedQueryStringsT>(value);
  }
  template <typename ForwardedQueryStringsT = QueryStringObject>
  CacheSettings& WithForwardedQueryStrings(ForwardedQueryStringsT&& value) {
    SetForwardedQueryStrings(std::forward<ForwardedQueryStringsT>(value));
    return *this;
  }
 private:
  long long m_defaultTTL{0};
 
  long long m_minimumTTL{0};
 
  long long m_maximumTTL{0};
 
  Aws::String m_allowedHTTPMethods;
 
  Aws::String m_cachedHTTPMethods;
 
  CookieObject m_forwardedCookies;
 
  HeaderObject m_forwardedHeaders;
 
  QueryStringObject m_forwardedQueryStrings;
  bool m_defaultTTLHasBeenSet = false;
  bool m_minimumTTLHasBeenSet = false;
  bool m_maximumTTLHasBeenSet = false;
  bool m_allowedHTTPMethodsHasBeenSet = false;
  bool m_cachedHTTPMethodsHasBeenSet = false;
  bool m_forwardedCookiesHasBeenSet = false;
  bool m_forwardedHeadersHasBeenSet = false;
  bool m_forwardedQueryStringsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lightsail
}  // namespace Aws