S3CopyObjectOperation.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/s3control/S3Control_EXPORTS.h>
#include <aws/s3control/model/S3AnnotationDirective.h>
#include <aws/s3control/model/S3CannedAccessControlList.h>
#include <aws/s3control/model/S3ChecksumAlgorithm.h>
#include <aws/s3control/model/S3Grant.h>
#include <aws/s3control/model/S3MetadataDirective.h>
#include <aws/s3control/model/S3ObjectLockEventHold.h>
#include <aws/s3control/model/S3ObjectLockEventHoldDuration.h>
#include <aws/s3control/model/S3ObjectLockLegalHoldStatus.h>
#include <aws/s3control/model/S3ObjectLockMode.h>
#include <aws/s3control/model/S3ObjectMetadata.h>
#include <aws/s3control/model/S3StorageClass.h>
#include <aws/s3control/model/S3Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace S3Control {
namespace Model {
 
class S3CopyObjectOperation {
 public:
  AWS_S3CONTROL_API S3CopyObjectOperation() = default;
  AWS_S3CONTROL_API S3CopyObjectOperation(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_S3CONTROL_API S3CopyObjectOperation& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_S3CONTROL_API void AddToNode(Aws::Utils::Xml::XmlNode& parentNode) const;
 
 
  inline const Aws::String& GetTargetResource() const { return m_targetResource; }
  inline bool TargetResourceHasBeenSet() const { return m_targetResourceHasBeenSet; }
  template <typename TargetResourceT = Aws::String>
  void SetTargetResource(TargetResourceT&& value) {
    m_targetResourceHasBeenSet = true;
    m_targetResource = std::forward<TargetResourceT>(value);
  }
  template <typename TargetResourceT = Aws::String>
  S3CopyObjectOperation& WithTargetResource(TargetResourceT&& value) {
    SetTargetResource(std::forward<TargetResourceT>(value));
    return *this;
  }
 
 
  inline S3CannedAccessControlList GetCannedAccessControlList() const { return m_cannedAccessControlList; }
  inline bool CannedAccessControlListHasBeenSet() const { return m_cannedAccessControlListHasBeenSet; }
  inline void SetCannedAccessControlList(S3CannedAccessControlList value) {
    m_cannedAccessControlListHasBeenSet = true;
    m_cannedAccessControlList = value;
  }
  inline S3CopyObjectOperation& WithCannedAccessControlList(S3CannedAccessControlList value) {
    SetCannedAccessControlList(value);
    return *this;
  }
 
 
  inline const Aws::Vector<S3Grant>& GetAccessControlGrants() const { return m_accessControlGrants; }
  inline bool AccessControlGrantsHasBeenSet() const { return m_accessControlGrantsHasBeenSet; }
  template <typename AccessControlGrantsT = Aws::Vector<S3Grant>>
  void SetAccessControlGrants(AccessControlGrantsT&& value) {
    m_accessControlGrantsHasBeenSet = true;
    m_accessControlGrants = std::forward<AccessControlGrantsT>(value);
  }
  template <typename AccessControlGrantsT = Aws::Vector<S3Grant>>
  S3CopyObjectOperation& WithAccessControlGrants(AccessControlGrantsT&& value) {
    SetAccessControlGrants(std::forward<AccessControlGrantsT>(value));
    return *this;
  }
  template <typename AccessControlGrantsT = S3Grant>
  S3CopyObjectOperation& AddAccessControlGrants(AccessControlGrantsT&& value) {
    m_accessControlGrantsHasBeenSet = true;
    m_accessControlGrants.emplace_back(std::forward<AccessControlGrantsT>(value));
    return *this;
  }
 
 
  inline S3MetadataDirective GetMetadataDirective() const { return m_metadataDirective; }
  inline bool MetadataDirectiveHasBeenSet() const { return m_metadataDirectiveHasBeenSet; }
  inline void SetMetadataDirective(S3MetadataDirective value) {
    m_metadataDirectiveHasBeenSet = true;
    m_metadataDirective = value;
  }
  inline S3CopyObjectOperation& WithMetadataDirective(S3MetadataDirective value) {
    SetMetadataDirective(value);
    return *this;
  }
 
 
  inline S3AnnotationDirective GetAnnotationDirective() const { return m_annotationDirective; }
  inline bool AnnotationDirectiveHasBeenSet() const { return m_annotationDirectiveHasBeenSet; }
  inline void SetAnnotationDirective(S3AnnotationDirective value) {
    m_annotationDirectiveHasBeenSet = true;
    m_annotationDirective = value;
  }
  inline S3CopyObjectOperation& WithAnnotationDirective(S3AnnotationDirective value) {
    SetAnnotationDirective(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetModifiedSinceConstraint() const { return m_modifiedSinceConstraint; }
  inline bool ModifiedSinceConstraintHasBeenSet() const { return m_modifiedSinceConstraintHasBeenSet; }
  template <typename ModifiedSinceConstraintT = Aws::Utils::DateTime>
  void SetModifiedSinceConstraint(ModifiedSinceConstraintT&& value) {
    m_modifiedSinceConstraintHasBeenSet = true;
    m_modifiedSinceConstraint = std::forward<ModifiedSinceConstraintT>(value);
  }
  template <typename ModifiedSinceConstraintT = Aws::Utils::DateTime>
  S3CopyObjectOperation& WithModifiedSinceConstraint(ModifiedSinceConstraintT&& value) {
    SetModifiedSinceConstraint(std::forward<ModifiedSinceConstraintT>(value));
    return *this;
  }
 
 
  inline const S3ObjectMetadata& GetNewObjectMetadata() const { return m_newObjectMetadata; }
  inline bool NewObjectMetadataHasBeenSet() const { return m_newObjectMetadataHasBeenSet; }
  template <typename NewObjectMetadataT = S3ObjectMetadata>
  void SetNewObjectMetadata(NewObjectMetadataT&& value) {
    m_newObjectMetadataHasBeenSet = true;
    m_newObjectMetadata = std::forward<NewObjectMetadataT>(value);
  }
  template <typename NewObjectMetadataT = S3ObjectMetadata>
  S3CopyObjectOperation& WithNewObjectMetadata(NewObjectMetadataT&& value) {
    SetNewObjectMetadata(std::forward<NewObjectMetadataT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<S3Tag>& GetNewObjectTagging() const { return m_newObjectTagging; }
  inline bool NewObjectTaggingHasBeenSet() const { return m_newObjectTaggingHasBeenSet; }
  template <typename NewObjectTaggingT = Aws::Vector<S3Tag>>
  void SetNewObjectTagging(NewObjectTaggingT&& value) {
    m_newObjectTaggingHasBeenSet = true;
    m_newObjectTagging = std::forward<NewObjectTaggingT>(value);
  }
  template <typename NewObjectTaggingT = Aws::Vector<S3Tag>>
  S3CopyObjectOperation& WithNewObjectTagging(NewObjectTaggingT&& value) {
    SetNewObjectTagging(std::forward<NewObjectTaggingT>(value));
    return *this;
  }
  template <typename NewObjectTaggingT = S3Tag>
  S3CopyObjectOperation& AddNewObjectTagging(NewObjectTaggingT&& value) {
    m_newObjectTaggingHasBeenSet = true;
    m_newObjectTagging.emplace_back(std::forward<NewObjectTaggingT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRedirectLocation() const { return m_redirectLocation; }
  inline bool RedirectLocationHasBeenSet() const { return m_redirectLocationHasBeenSet; }
  template <typename RedirectLocationT = Aws::String>
  void SetRedirectLocation(RedirectLocationT&& value) {
    m_redirectLocationHasBeenSet = true;
    m_redirectLocation = std::forward<RedirectLocationT>(value);
  }
  template <typename RedirectLocationT = Aws::String>
  S3CopyObjectOperation& WithRedirectLocation(RedirectLocationT&& value) {
    SetRedirectLocation(std::forward<RedirectLocationT>(value));
    return *this;
  }
 
 
  inline bool GetRequesterPays() const { return m_requesterPays; }
  inline bool RequesterPaysHasBeenSet() const { return m_requesterPaysHasBeenSet; }
  inline void SetRequesterPays(bool value) {
    m_requesterPaysHasBeenSet = true;
    m_requesterPays = value;
  }
  inline S3CopyObjectOperation& WithRequesterPays(bool value) {
    SetRequesterPays(value);
    return *this;
  }
 
 
  inline S3StorageClass GetStorageClass() const { return m_storageClass; }
  inline bool StorageClassHasBeenSet() const { return m_storageClassHasBeenSet; }
  inline void SetStorageClass(S3StorageClass value) {
    m_storageClassHasBeenSet = true;
    m_storageClass = value;
  }
  inline S3CopyObjectOperation& WithStorageClass(S3StorageClass value) {
    SetStorageClass(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUnModifiedSinceConstraint() const { return m_unModifiedSinceConstraint; }
  inline bool UnModifiedSinceConstraintHasBeenSet() const { return m_unModifiedSinceConstraintHasBeenSet; }
  template <typename UnModifiedSinceConstraintT = Aws::Utils::DateTime>
  void SetUnModifiedSinceConstraint(UnModifiedSinceConstraintT&& value) {
    m_unModifiedSinceConstraintHasBeenSet = true;
    m_unModifiedSinceConstraint = std::forward<UnModifiedSinceConstraintT>(value);
  }
  template <typename UnModifiedSinceConstraintT = Aws::Utils::DateTime>
  S3CopyObjectOperation& WithUnModifiedSinceConstraint(UnModifiedSinceConstraintT&& value) {
    SetUnModifiedSinceConstraint(std::forward<UnModifiedSinceConstraintT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSSEAwsKmsKeyId() const { return m_sSEAwsKmsKeyId; }
  inline bool SSEAwsKmsKeyIdHasBeenSet() const { return m_sSEAwsKmsKeyIdHasBeenSet; }
  template <typename SSEAwsKmsKeyIdT = Aws::String>
  void SetSSEAwsKmsKeyId(SSEAwsKmsKeyIdT&& value) {
    m_sSEAwsKmsKeyIdHasBeenSet = true;
    m_sSEAwsKmsKeyId = std::forward<SSEAwsKmsKeyIdT>(value);
  }
  template <typename SSEAwsKmsKeyIdT = Aws::String>
  S3CopyObjectOperation& WithSSEAwsKmsKeyId(SSEAwsKmsKeyIdT&& value) {
    SetSSEAwsKmsKeyId(std::forward<SSEAwsKmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetKeyPrefix() const { return m_targetKeyPrefix; }
  inline bool TargetKeyPrefixHasBeenSet() const { return m_targetKeyPrefixHasBeenSet; }
  template <typename TargetKeyPrefixT = Aws::String>
  void SetTargetKeyPrefix(TargetKeyPrefixT&& value) {
    m_targetKeyPrefixHasBeenSet = true;
    m_targetKeyPrefix = std::forward<TargetKeyPrefixT>(value);
  }
  template <typename TargetKeyPrefixT = Aws::String>
  S3CopyObjectOperation& WithTargetKeyPrefix(TargetKeyPrefixT&& value) {
    SetTargetKeyPrefix(std::forward<TargetKeyPrefixT>(value));
    return *this;
  }
 
 
  inline S3ObjectLockLegalHoldStatus GetObjectLockLegalHoldStatus() const { return m_objectLockLegalHoldStatus; }
  inline bool ObjectLockLegalHoldStatusHasBeenSet() const { return m_objectLockLegalHoldStatusHasBeenSet; }
  inline void SetObjectLockLegalHoldStatus(S3ObjectLockLegalHoldStatus value) {
    m_objectLockLegalHoldStatusHasBeenSet = true;
    m_objectLockLegalHoldStatus = value;
  }
  inline S3CopyObjectOperation& WithObjectLockLegalHoldStatus(S3ObjectLockLegalHoldStatus value) {
    SetObjectLockLegalHoldStatus(value);
    return *this;
  }
 
 
  inline S3ObjectLockMode GetObjectLockMode() const { return m_objectLockMode; }
  inline bool ObjectLockModeHasBeenSet() const { return m_objectLockModeHasBeenSet; }
  inline void SetObjectLockMode(S3ObjectLockMode value) {
    m_objectLockModeHasBeenSet = true;
    m_objectLockMode = value;
  }
  inline S3CopyObjectOperation& WithObjectLockMode(S3ObjectLockMode value) {
    SetObjectLockMode(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetObjectLockRetainUntilDate() const { return m_objectLockRetainUntilDate; }
  inline bool ObjectLockRetainUntilDateHasBeenSet() const { return m_objectLockRetainUntilDateHasBeenSet; }
  template <typename ObjectLockRetainUntilDateT = Aws::Utils::DateTime>
  void SetObjectLockRetainUntilDate(ObjectLockRetainUntilDateT&& value) {
    m_objectLockRetainUntilDateHasBeenSet = true;
    m_objectLockRetainUntilDate = std::forward<ObjectLockRetainUntilDateT>(value);
  }
  template <typename ObjectLockRetainUntilDateT = Aws::Utils::DateTime>
  S3CopyObjectOperation& WithObjectLockRetainUntilDate(ObjectLockRetainUntilDateT&& value) {
    SetObjectLockRetainUntilDate(std::forward<ObjectLockRetainUntilDateT>(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 S3CopyObjectOperation& WithBucketKeyEnabled(bool value) {
    SetBucketKeyEnabled(value);
    return *this;
  }
 
 
  inline S3ChecksumAlgorithm GetChecksumAlgorithm() const { return m_checksumAlgorithm; }
  inline bool ChecksumAlgorithmHasBeenSet() const { return m_checksumAlgorithmHasBeenSet; }
  inline void SetChecksumAlgorithm(S3ChecksumAlgorithm value) {
    m_checksumAlgorithmHasBeenSet = true;
    m_checksumAlgorithm = value;
  }
  inline S3CopyObjectOperation& WithChecksumAlgorithm(S3ChecksumAlgorithm value) {
    SetChecksumAlgorithm(value);
    return *this;
  }
 
 
  inline S3ObjectLockEventHold GetObjectLockEventHold() const { return m_objectLockEventHold; }
  inline bool ObjectLockEventHoldHasBeenSet() const { return m_objectLockEventHoldHasBeenSet; }
  inline void SetObjectLockEventHold(S3ObjectLockEventHold value) {
    m_objectLockEventHoldHasBeenSet = true;
    m_objectLockEventHold = value;
  }
  inline S3CopyObjectOperation& WithObjectLockEventHold(S3ObjectLockEventHold value) {
    SetObjectLockEventHold(value);
    return *this;
  }
 
 
  inline const S3ObjectLockEventHoldDuration& GetObjectLockEventHoldDuration() const { return m_objectLockEventHoldDuration; }
  inline bool ObjectLockEventHoldDurationHasBeenSet() const { return m_objectLockEventHoldDurationHasBeenSet; }
  template <typename ObjectLockEventHoldDurationT = S3ObjectLockEventHoldDuration>
  void SetObjectLockEventHoldDuration(ObjectLockEventHoldDurationT&& value) {
    m_objectLockEventHoldDurationHasBeenSet = true;
    m_objectLockEventHoldDuration = std::forward<ObjectLockEventHoldDurationT>(value);
  }
  template <typename ObjectLockEventHoldDurationT = S3ObjectLockEventHoldDuration>
  S3CopyObjectOperation& WithObjectLockEventHoldDuration(ObjectLockEventHoldDurationT&& value) {
    SetObjectLockEventHoldDuration(std::forward<ObjectLockEventHoldDurationT>(value));
    return *this;
  }
 private:
  Aws::String m_targetResource;
 
  S3CannedAccessControlList m_cannedAccessControlList{S3CannedAccessControlList::NOT_SET};
 
  Aws::Vector<S3Grant> m_accessControlGrants;
 
  S3MetadataDirective m_metadataDirective{S3MetadataDirective::NOT_SET};
 
  S3AnnotationDirective m_annotationDirective{S3AnnotationDirective::NOT_SET};
 
  Aws::Utils::DateTime m_modifiedSinceConstraint{};
 
  S3ObjectMetadata m_newObjectMetadata;
 
  Aws::Vector<S3Tag> m_newObjectTagging;
 
  Aws::String m_redirectLocation;
 
  bool m_requesterPays{false};
 
  S3StorageClass m_storageClass{S3StorageClass::NOT_SET};
 
  Aws::Utils::DateTime m_unModifiedSinceConstraint{};
 
  Aws::String m_sSEAwsKmsKeyId;
 
  Aws::String m_targetKeyPrefix;
 
  S3ObjectLockLegalHoldStatus m_objectLockLegalHoldStatus{S3ObjectLockLegalHoldStatus::NOT_SET};
 
  S3ObjectLockMode m_objectLockMode{S3ObjectLockMode::NOT_SET};
 
  Aws::Utils::DateTime m_objectLockRetainUntilDate{};
 
  bool m_bucketKeyEnabled{false};
 
  S3ChecksumAlgorithm m_checksumAlgorithm{S3ChecksumAlgorithm::NOT_SET};
 
  S3ObjectLockEventHold m_objectLockEventHold{S3ObjectLockEventHold::NOT_SET};
 
  S3ObjectLockEventHoldDuration m_objectLockEventHoldDuration;
  bool m_targetResourceHasBeenSet = false;
  bool m_cannedAccessControlListHasBeenSet = false;
  bool m_accessControlGrantsHasBeenSet = false;
  bool m_metadataDirectiveHasBeenSet = false;
  bool m_annotationDirectiveHasBeenSet = false;
  bool m_modifiedSinceConstraintHasBeenSet = false;
  bool m_newObjectMetadataHasBeenSet = false;
  bool m_newObjectTaggingHasBeenSet = false;
  bool m_redirectLocationHasBeenSet = false;
  bool m_requesterPaysHasBeenSet = false;
  bool m_storageClassHasBeenSet = false;
  bool m_unModifiedSinceConstraintHasBeenSet = false;
  bool m_sSEAwsKmsKeyIdHasBeenSet = false;
  bool m_targetKeyPrefixHasBeenSet = false;
  bool m_objectLockLegalHoldStatusHasBeenSet = false;
  bool m_objectLockModeHasBeenSet = false;
  bool m_objectLockRetainUntilDateHasBeenSet = false;
  bool m_bucketKeyEnabledHasBeenSet = false;
  bool m_checksumAlgorithmHasBeenSet = false;
  bool m_objectLockEventHoldHasBeenSet = false;
  bool m_objectLockEventHoldDurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace S3Control
}  // namespace Aws