RecoveryPointByResource.h

 
#pragma once
#include <aws/backup/Backup_EXPORTS.h>
#include <aws/backup/model/AggregatedScanResult.h>
#include <aws/backup/model/EncryptionKeyType.h>
#include <aws/backup/model/IndexStatus.h>
#include <aws/backup/model/RecoveryPointStatus.h>
#include <aws/backup/model/VaultType.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Backup {
namespace Model {
 
class RecoveryPointByResource {
 public:
  AWS_BACKUP_API RecoveryPointByResource() = default;
  AWS_BACKUP_API RecoveryPointByResource(Aws::Utils::Json::JsonView jsonValue);
  AWS_BACKUP_API RecoveryPointByResource& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BACKUP_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetRecoveryPointArn() const { return m_recoveryPointArn; }
  inline bool RecoveryPointArnHasBeenSet() const { return m_recoveryPointArnHasBeenSet; }
  template <typename RecoveryPointArnT = Aws::String>
  void SetRecoveryPointArn(RecoveryPointArnT&& value) {
    m_recoveryPointArnHasBeenSet = true;
    m_recoveryPointArn = std::forward<RecoveryPointArnT>(value);
  }
  template <typename RecoveryPointArnT = Aws::String>
  RecoveryPointByResource& WithRecoveryPointArn(RecoveryPointArnT&& value) {
    SetRecoveryPointArn(std::forward<RecoveryPointArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationDate() const { return m_creationDate; }
  inline bool CreationDateHasBeenSet() const { return m_creationDateHasBeenSet; }
  template <typename CreationDateT = Aws::Utils::DateTime>
  void SetCreationDate(CreationDateT&& value) {
    m_creationDateHasBeenSet = true;
    m_creationDate = std::forward<CreationDateT>(value);
  }
  template <typename CreationDateT = Aws::Utils::DateTime>
  RecoveryPointByResource& WithCreationDate(CreationDateT&& value) {
    SetCreationDate(std::forward<CreationDateT>(value));
    return *this;
  }
 
 
  inline RecoveryPointStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(RecoveryPointStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline RecoveryPointByResource& WithStatus(RecoveryPointStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStatusMessage() const { return m_statusMessage; }
  inline bool StatusMessageHasBeenSet() const { return m_statusMessageHasBeenSet; }
  template <typename StatusMessageT = Aws::String>
  void SetStatusMessage(StatusMessageT&& value) {
    m_statusMessageHasBeenSet = true;
    m_statusMessage = std::forward<StatusMessageT>(value);
  }
  template <typename StatusMessageT = Aws::String>
  RecoveryPointByResource& WithStatusMessage(StatusMessageT&& value) {
    SetStatusMessage(std::forward<StatusMessageT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEncryptionKeyArn() const { return m_encryptionKeyArn; }
  inline bool EncryptionKeyArnHasBeenSet() const { return m_encryptionKeyArnHasBeenSet; }
  template <typename EncryptionKeyArnT = Aws::String>
  void SetEncryptionKeyArn(EncryptionKeyArnT&& value) {
    m_encryptionKeyArnHasBeenSet = true;
    m_encryptionKeyArn = std::forward<EncryptionKeyArnT>(value);
  }
  template <typename EncryptionKeyArnT = Aws::String>
  RecoveryPointByResource& WithEncryptionKeyArn(EncryptionKeyArnT&& value) {
    SetEncryptionKeyArn(std::forward<EncryptionKeyArnT>(value));
    return *this;
  }
 
 
  inline long long GetBackupSizeBytes() const { return m_backupSizeBytes; }
  inline bool BackupSizeBytesHasBeenSet() const { return m_backupSizeBytesHasBeenSet; }
  inline void SetBackupSizeBytes(long long value) {
    m_backupSizeBytesHasBeenSet = true;
    m_backupSizeBytes = value;
  }
  inline RecoveryPointByResource& WithBackupSizeBytes(long long value) {
    SetBackupSizeBytes(value);
    return *this;
  }
 
 
  inline const Aws::String& GetBackupVaultName() const { return m_backupVaultName; }
  inline bool BackupVaultNameHasBeenSet() const { return m_backupVaultNameHasBeenSet; }
  template <typename BackupVaultNameT = Aws::String>
  void SetBackupVaultName(BackupVaultNameT&& value) {
    m_backupVaultNameHasBeenSet = true;
    m_backupVaultName = std::forward<BackupVaultNameT>(value);
  }
  template <typename BackupVaultNameT = Aws::String>
  RecoveryPointByResource& WithBackupVaultName(BackupVaultNameT&& value) {
    SetBackupVaultName(std::forward<BackupVaultNameT>(value));
    return *this;
  }
 
 
  inline bool GetIsParent() const { return m_isParent; }
  inline bool IsParentHasBeenSet() const { return m_isParentHasBeenSet; }
  inline void SetIsParent(bool value) {
    m_isParentHasBeenSet = true;
    m_isParent = value;
  }
  inline RecoveryPointByResource& WithIsParent(bool value) {
    SetIsParent(value);
    return *this;
  }
 
 
  inline const Aws::String& GetParentRecoveryPointArn() const { return m_parentRecoveryPointArn; }
  inline bool ParentRecoveryPointArnHasBeenSet() const { return m_parentRecoveryPointArnHasBeenSet; }
  template <typename ParentRecoveryPointArnT = Aws::String>
  void SetParentRecoveryPointArn(ParentRecoveryPointArnT&& value) {
    m_parentRecoveryPointArnHasBeenSet = true;
    m_parentRecoveryPointArn = std::forward<ParentRecoveryPointArnT>(value);
  }
  template <typename ParentRecoveryPointArnT = Aws::String>
  RecoveryPointByResource& WithParentRecoveryPointArn(ParentRecoveryPointArnT&& value) {
    SetParentRecoveryPointArn(std::forward<ParentRecoveryPointArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceName() const { return m_resourceName; }
  inline bool ResourceNameHasBeenSet() const { return m_resourceNameHasBeenSet; }
  template <typename ResourceNameT = Aws::String>
  void SetResourceName(ResourceNameT&& value) {
    m_resourceNameHasBeenSet = true;
    m_resourceName = std::forward<ResourceNameT>(value);
  }
  template <typename ResourceNameT = Aws::String>
  RecoveryPointByResource& WithResourceName(ResourceNameT&& value) {
    SetResourceName(std::forward<ResourceNameT>(value));
    return *this;
  }
 
 
  inline VaultType GetVaultType() const { return m_vaultType; }
  inline bool VaultTypeHasBeenSet() const { return m_vaultTypeHasBeenSet; }
  inline void SetVaultType(VaultType value) {
    m_vaultTypeHasBeenSet = true;
    m_vaultType = value;
  }
  inline RecoveryPointByResource& WithVaultType(VaultType value) {
    SetVaultType(value);
    return *this;
  }
 
 
  inline IndexStatus GetIndexStatus() const { return m_indexStatus; }
  inline bool IndexStatusHasBeenSet() const { return m_indexStatusHasBeenSet; }
  inline void SetIndexStatus(IndexStatus value) {
    m_indexStatusHasBeenSet = true;
    m_indexStatus = value;
  }
  inline RecoveryPointByResource& WithIndexStatus(IndexStatus value) {
    SetIndexStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetIndexStatusMessage() const { return m_indexStatusMessage; }
  inline bool IndexStatusMessageHasBeenSet() const { return m_indexStatusMessageHasBeenSet; }
  template <typename IndexStatusMessageT = Aws::String>
  void SetIndexStatusMessage(IndexStatusMessageT&& value) {
    m_indexStatusMessageHasBeenSet = true;
    m_indexStatusMessage = std::forward<IndexStatusMessageT>(value);
  }
  template <typename IndexStatusMessageT = Aws::String>
  RecoveryPointByResource& WithIndexStatusMessage(IndexStatusMessageT&& value) {
    SetIndexStatusMessage(std::forward<IndexStatusMessageT>(value));
    return *this;
  }
 
 
  inline EncryptionKeyType GetEncryptionKeyType() const { return m_encryptionKeyType; }
  inline bool EncryptionKeyTypeHasBeenSet() const { return m_encryptionKeyTypeHasBeenSet; }
  inline void SetEncryptionKeyType(EncryptionKeyType value) {
    m_encryptionKeyTypeHasBeenSet = true;
    m_encryptionKeyType = value;
  }
  inline RecoveryPointByResource& WithEncryptionKeyType(EncryptionKeyType value) {
    SetEncryptionKeyType(value);
    return *this;
  }
 
 
  inline const AggregatedScanResult& GetAggregatedScanResult() const { return m_aggregatedScanResult; }
  inline bool AggregatedScanResultHasBeenSet() const { return m_aggregatedScanResultHasBeenSet; }
  template <typename AggregatedScanResultT = AggregatedScanResult>
  void SetAggregatedScanResult(AggregatedScanResultT&& value) {
    m_aggregatedScanResultHasBeenSet = true;
    m_aggregatedScanResult = std::forward<AggregatedScanResultT>(value);
  }
  template <typename AggregatedScanResultT = AggregatedScanResult>
  RecoveryPointByResource& WithAggregatedScanResult(AggregatedScanResultT&& value) {
    SetAggregatedScanResult(std::forward<AggregatedScanResultT>(value));
    return *this;
  }
 private:
  Aws::String m_recoveryPointArn;
 
  Aws::Utils::DateTime m_creationDate{};
 
  RecoveryPointStatus m_status{RecoveryPointStatus::NOT_SET};
 
  Aws::String m_statusMessage;
 
  Aws::String m_encryptionKeyArn;
 
  long long m_backupSizeBytes{0};
 
  Aws::String m_backupVaultName;
 
  bool m_isParent{false};
 
  Aws::String m_parentRecoveryPointArn;
 
  Aws::String m_resourceName;
 
  VaultType m_vaultType{VaultType::NOT_SET};
 
  IndexStatus m_indexStatus{IndexStatus::NOT_SET};
 
  Aws::String m_indexStatusMessage;
 
  EncryptionKeyType m_encryptionKeyType{EncryptionKeyType::NOT_SET};
 
  AggregatedScanResult m_aggregatedScanResult;
  bool m_recoveryPointArnHasBeenSet = false;
  bool m_creationDateHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusMessageHasBeenSet = false;
  bool m_encryptionKeyArnHasBeenSet = false;
  bool m_backupSizeBytesHasBeenSet = false;
  bool m_backupVaultNameHasBeenSet = false;
  bool m_isParentHasBeenSet = false;
  bool m_parentRecoveryPointArnHasBeenSet = false;
  bool m_resourceNameHasBeenSet = false;
  bool m_vaultTypeHasBeenSet = false;
  bool m_indexStatusHasBeenSet = false;
  bool m_indexStatusMessageHasBeenSet = false;
  bool m_encryptionKeyTypeHasBeenSet = false;
  bool m_aggregatedScanResultHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Backup
}  // namespace Aws