S3Object.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/macie2/Macie2_EXPORTS.h>
#include <aws/macie2/model/KeyValuePair.h>
#include <aws/macie2/model/ServerSideEncryption.h>
#include <aws/macie2/model/StorageClass.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Macie2 {
namespace Model {
 
class S3Object {
 public:
  AWS_MACIE2_API S3Object() = default;
  AWS_MACIE2_API S3Object(Aws::Utils::Json::JsonView jsonValue);
  AWS_MACIE2_API S3Object& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MACIE2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetBucketArn() const { return m_bucketArn; }
  inline bool BucketArnHasBeenSet() const { return m_bucketArnHasBeenSet; }
  template <typename BucketArnT = Aws::String>
  void SetBucketArn(BucketArnT&& value) {
    m_bucketArnHasBeenSet = true;
    m_bucketArn = std::forward<BucketArnT>(value);
  }
  template <typename BucketArnT = Aws::String>
  S3Object& WithBucketArn(BucketArnT&& value) {
    SetBucketArn(std::forward<BucketArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetETag() const { return m_eTag; }
  inline bool ETagHasBeenSet() const { return m_eTagHasBeenSet; }
  template <typename ETagT = Aws::String>
  void SetETag(ETagT&& value) {
    m_eTagHasBeenSet = true;
    m_eTag = std::forward<ETagT>(value);
  }
  template <typename ETagT = Aws::String>
  S3Object& WithETag(ETagT&& value) {
    SetETag(std::forward<ETagT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExtension() const { return m_extension; }
  inline bool ExtensionHasBeenSet() const { return m_extensionHasBeenSet; }
  template <typename ExtensionT = Aws::String>
  void SetExtension(ExtensionT&& value) {
    m_extensionHasBeenSet = true;
    m_extension = std::forward<ExtensionT>(value);
  }
  template <typename ExtensionT = Aws::String>
  S3Object& WithExtension(ExtensionT&& value) {
    SetExtension(std::forward<ExtensionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKey() const { return m_key; }
  inline bool KeyHasBeenSet() const { return m_keyHasBeenSet; }
  template <typename KeyT = Aws::String>
  void SetKey(KeyT&& value) {
    m_keyHasBeenSet = true;
    m_key = std::forward<KeyT>(value);
  }
  template <typename KeyT = Aws::String>
  S3Object& WithKey(KeyT&& value) {
    SetKey(std::forward<KeyT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastModified() const { return m_lastModified; }
  inline bool LastModifiedHasBeenSet() const { return m_lastModifiedHasBeenSet; }
  template <typename LastModifiedT = Aws::Utils::DateTime>
  void SetLastModified(LastModifiedT&& value) {
    m_lastModifiedHasBeenSet = true;
    m_lastModified = std::forward<LastModifiedT>(value);
  }
  template <typename LastModifiedT = Aws::Utils::DateTime>
  S3Object& WithLastModified(LastModifiedT&& value) {
    SetLastModified(std::forward<LastModifiedT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPath() const { return m_path; }
  inline bool PathHasBeenSet() const { return m_pathHasBeenSet; }
  template <typename PathT = Aws::String>
  void SetPath(PathT&& value) {
    m_pathHasBeenSet = true;
    m_path = std::forward<PathT>(value);
  }
  template <typename PathT = Aws::String>
  S3Object& WithPath(PathT&& value) {
    SetPath(std::forward<PathT>(value));
    return *this;
  }
 
 
  inline bool GetPublicAccess() const { return m_publicAccess; }
  inline bool PublicAccessHasBeenSet() const { return m_publicAccessHasBeenSet; }
  inline void SetPublicAccess(bool value) {
    m_publicAccessHasBeenSet = true;
    m_publicAccess = value;
  }
  inline S3Object& WithPublicAccess(bool value) {
    SetPublicAccess(value);
    return *this;
  }
 
 
  inline const ServerSideEncryption& GetServerSideEncryption() const { return m_serverSideEncryption; }
  inline bool ServerSideEncryptionHasBeenSet() const { return m_serverSideEncryptionHasBeenSet; }
  template <typename ServerSideEncryptionT = ServerSideEncryption>
  void SetServerSideEncryption(ServerSideEncryptionT&& value) {
    m_serverSideEncryptionHasBeenSet = true;
    m_serverSideEncryption = std::forward<ServerSideEncryptionT>(value);
  }
  template <typename ServerSideEncryptionT = ServerSideEncryption>
  S3Object& WithServerSideEncryption(ServerSideEncryptionT&& value) {
    SetServerSideEncryption(std::forward<ServerSideEncryptionT>(value));
    return *this;
  }
 
 
  inline long long GetSize() const { return m_size; }
  inline bool SizeHasBeenSet() const { return m_sizeHasBeenSet; }
  inline void SetSize(long long value) {
    m_sizeHasBeenSet = true;
    m_size = value;
  }
  inline S3Object& WithSize(long long value) {
    SetSize(value);
    return *this;
  }
 
 
  inline StorageClass GetStorageClass() const { return m_storageClass; }
  inline bool StorageClassHasBeenSet() const { return m_storageClassHasBeenSet; }
  inline void SetStorageClass(StorageClass value) {
    m_storageClassHasBeenSet = true;
    m_storageClass = value;
  }
  inline S3Object& WithStorageClass(StorageClass value) {
    SetStorageClass(value);
    return *this;
  }
 
 
  inline const Aws::Vector<KeyValuePair>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<KeyValuePair>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<KeyValuePair>>
  S3Object& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = KeyValuePair>
  S3Object& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVersionId() const { return m_versionId; }
  inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
  template <typename VersionIdT = Aws::String>
  void SetVersionId(VersionIdT&& value) {
    m_versionIdHasBeenSet = true;
    m_versionId = std::forward<VersionIdT>(value);
  }
  template <typename VersionIdT = Aws::String>
  S3Object& WithVersionId(VersionIdT&& value) {
    SetVersionId(std::forward<VersionIdT>(value));
    return *this;
  }
 private:
  Aws::String m_bucketArn;
 
  Aws::String m_eTag;
 
  Aws::String m_extension;
 
  Aws::String m_key;
 
  Aws::Utils::DateTime m_lastModified{};
 
  Aws::String m_path;
 
  bool m_publicAccess{false};
 
  ServerSideEncryption m_serverSideEncryption;
 
  long long m_size{0};
 
  StorageClass m_storageClass{StorageClass::NOT_SET};
 
  Aws::Vector<KeyValuePair> m_tags;
 
  Aws::String m_versionId;
  bool m_bucketArnHasBeenSet = false;
  bool m_eTagHasBeenSet = false;
  bool m_extensionHasBeenSet = false;
  bool m_keyHasBeenSet = false;
  bool m_lastModifiedHasBeenSet = false;
  bool m_pathHasBeenSet = false;
  bool m_publicAccessHasBeenSet = false;
  bool m_serverSideEncryptionHasBeenSet = false;
  bool m_sizeHasBeenSet = false;
  bool m_storageClassHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_versionIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Macie2
}  // namespace Aws