ServerSideEncryptionRule.h

 
#pragma once
#include <aws/s3-crt/S3Crt_EXPORTS.h>
#include <aws/s3-crt/model/BlockedEncryptionTypes.h>
#include <aws/s3-crt/model/ServerSideEncryptionByDefault.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace S3Crt {
namespace Model {
 
class ServerSideEncryptionRule {
 public:
  AWS_S3CRT_API ServerSideEncryptionRule() = default;
  AWS_S3CRT_API ServerSideEncryptionRule(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_S3CRT_API ServerSideEncryptionRule& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_S3CRT_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline const ServerSideEncryptionByDefault& GetApplyServerSideEncryptionByDefault() const { return m_applyServerSideEncryptionByDefault; }
  inline bool ApplyServerSideEncryptionByDefaultHasBeenSet() const { return m_applyServerSideEncryptionByDefaultHasBeenSet; }
  template <typename ApplyServerSideEncryptionByDefaultT = ServerSideEncryptionByDefault>
  void SetApplyServerSideEncryptionByDefault(ApplyServerSideEncryptionByDefaultT&& value) {
    m_applyServerSideEncryptionByDefaultHasBeenSet = true;
    m_applyServerSideEncryptionByDefault = std::forward<ApplyServerSideEncryptionByDefaultT>(value);
  }
  template <typename ApplyServerSideEncryptionByDefaultT = ServerSideEncryptionByDefault>
  ServerSideEncryptionRule& WithApplyServerSideEncryptionByDefault(ApplyServerSideEncryptionByDefaultT&& value) {
    SetApplyServerSideEncryptionByDefault(std::forward<ApplyServerSideEncryptionByDefaultT>(value));
    return *this;
  }
 
 
  inline bool GetBucketKeyEnabled() const { return m_bucketKeyEnabled; }
  inline bool BucketKeyEnabledHasBeenSet() const { return m_bucketKeyEnabledHasBeenSet; }
  inline void SetBucketKeyEnabled(bool value) {
    m_bucketKeyEnabledHasBeenSet = true;
    m_bucketKeyEnabled = value;
  }
  inline ServerSideEncryptionRule& WithBucketKeyEnabled(bool value) {
    SetBucketKeyEnabled(value);
    return *this;
  }
 
 
  inline const BlockedEncryptionTypes& GetBlockedEncryptionTypes() const { return m_blockedEncryptionTypes; }
  inline bool BlockedEncryptionTypesHasBeenSet() const { return m_blockedEncryptionTypesHasBeenSet; }
  template <typename BlockedEncryptionTypesT = BlockedEncryptionTypes>
  void SetBlockedEncryptionTypes(BlockedEncryptionTypesT&& value) {
    m_blockedEncryptionTypesHasBeenSet = true;
    m_blockedEncryptionTypes = std::forward<BlockedEncryptionTypesT>(value);
  }
  template <typename BlockedEncryptionTypesT = BlockedEncryptionTypes>
  ServerSideEncryptionRule& WithBlockedEncryptionTypes(BlockedEncryptionTypesT&& value) {
    SetBlockedEncryptionTypes(std::forward<BlockedEncryptionTypesT>(value));
    return *this;
  }
 private:
  ServerSideEncryptionByDefault m_applyServerSideEncryptionByDefault;
 
  bool m_bucketKeyEnabled{false};
 
  BlockedEncryptionTypes m_blockedEncryptionTypes;
  bool m_applyServerSideEncryptionByDefaultHasBeenSet = false;
  bool m_bucketKeyEnabledHasBeenSet = false;
  bool m_blockedEncryptionTypesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace S3Crt
}  // namespace Aws