StartBackupJobRequest.h

 
#pragma once
#include <aws/backup/BackupRequest.h>
#include <aws/backup/Backup_EXPORTS.h>
#include <aws/backup/model/Index.h>
#include <aws/backup/model/Lifecycle.h>
#include <aws/core/utils/UUID.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Backup {
namespace Model {
 
class StartBackupJobRequest : public BackupRequest {
 public:
  AWS_BACKUP_API StartBackupJobRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "StartBackupJob"; }
 
  AWS_BACKUP_API Aws::String SerializePayload() const override;
 
 
  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>
  StartBackupJobRequest& WithBackupVaultName(BackupVaultNameT&& value) {
    SetBackupVaultName(std::forward<BackupVaultNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLogicallyAirGappedBackupVaultArn() const { return m_logicallyAirGappedBackupVaultArn; }
  inline bool LogicallyAirGappedBackupVaultArnHasBeenSet() const { return m_logicallyAirGappedBackupVaultArnHasBeenSet; }
  template <typename LogicallyAirGappedBackupVaultArnT = Aws::String>
  void SetLogicallyAirGappedBackupVaultArn(LogicallyAirGappedBackupVaultArnT&& value) {
    m_logicallyAirGappedBackupVaultArnHasBeenSet = true;
    m_logicallyAirGappedBackupVaultArn = std::forward<LogicallyAirGappedBackupVaultArnT>(value);
  }
  template <typename LogicallyAirGappedBackupVaultArnT = Aws::String>
  StartBackupJobRequest& WithLogicallyAirGappedBackupVaultArn(LogicallyAirGappedBackupVaultArnT&& value) {
    SetLogicallyAirGappedBackupVaultArn(std::forward<LogicallyAirGappedBackupVaultArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetResourceArn() const { return m_resourceArn; }
  inline bool ResourceArnHasBeenSet() const { return m_resourceArnHasBeenSet; }
  template <typename ResourceArnT = Aws::String>
  void SetResourceArn(ResourceArnT&& value) {
    m_resourceArnHasBeenSet = true;
    m_resourceArn = std::forward<ResourceArnT>(value);
  }
  template <typename ResourceArnT = Aws::String>
  StartBackupJobRequest& WithResourceArn(ResourceArnT&& value) {
    SetResourceArn(std::forward<ResourceArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIamRoleArn() const { return m_iamRoleArn; }
  inline bool IamRoleArnHasBeenSet() const { return m_iamRoleArnHasBeenSet; }
  template <typename IamRoleArnT = Aws::String>
  void SetIamRoleArn(IamRoleArnT&& value) {
    m_iamRoleArnHasBeenSet = true;
    m_iamRoleArn = std::forward<IamRoleArnT>(value);
  }
  template <typename IamRoleArnT = Aws::String>
  StartBackupJobRequest& WithIamRoleArn(IamRoleArnT&& value) {
    SetIamRoleArn(std::forward<IamRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIdempotencyToken() const { return m_idempotencyToken; }
  inline bool IdempotencyTokenHasBeenSet() const { return m_idempotencyTokenHasBeenSet; }
  template <typename IdempotencyTokenT = Aws::String>
  void SetIdempotencyToken(IdempotencyTokenT&& value) {
    m_idempotencyTokenHasBeenSet = true;
    m_idempotencyToken = std::forward<IdempotencyTokenT>(value);
  }
  template <typename IdempotencyTokenT = Aws::String>
  StartBackupJobRequest& WithIdempotencyToken(IdempotencyTokenT&& value) {
    SetIdempotencyToken(std::forward<IdempotencyTokenT>(value));
    return *this;
  }
 
 
  inline long long GetStartWindowMinutes() const { return m_startWindowMinutes; }
  inline bool StartWindowMinutesHasBeenSet() const { return m_startWindowMinutesHasBeenSet; }
  inline void SetStartWindowMinutes(long long value) {
    m_startWindowMinutesHasBeenSet = true;
    m_startWindowMinutes = value;
  }
  inline StartBackupJobRequest& WithStartWindowMinutes(long long value) {
    SetStartWindowMinutes(value);
    return *this;
  }
 
 
  inline long long GetCompleteWindowMinutes() const { return m_completeWindowMinutes; }
  inline bool CompleteWindowMinutesHasBeenSet() const { return m_completeWindowMinutesHasBeenSet; }
  inline void SetCompleteWindowMinutes(long long value) {
    m_completeWindowMinutesHasBeenSet = true;
    m_completeWindowMinutes = value;
  }
  inline StartBackupJobRequest& WithCompleteWindowMinutes(long long value) {
    SetCompleteWindowMinutes(value);
    return *this;
  }
 
 
  inline const Lifecycle& GetLifecycle() const { return m_lifecycle; }
  inline bool LifecycleHasBeenSet() const { return m_lifecycleHasBeenSet; }
  template <typename LifecycleT = Lifecycle>
  void SetLifecycle(LifecycleT&& value) {
    m_lifecycleHasBeenSet = true;
    m_lifecycle = std::forward<LifecycleT>(value);
  }
  template <typename LifecycleT = Lifecycle>
  StartBackupJobRequest& WithLifecycle(LifecycleT&& value) {
    SetLifecycle(std::forward<LifecycleT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetRecoveryPointTags() const { return m_recoveryPointTags; }
  inline bool RecoveryPointTagsHasBeenSet() const { return m_recoveryPointTagsHasBeenSet; }
  template <typename RecoveryPointTagsT = Aws::Map<Aws::String, Aws::String>>
  void SetRecoveryPointTags(RecoveryPointTagsT&& value) {
    m_recoveryPointTagsHasBeenSet = true;
    m_recoveryPointTags = std::forward<RecoveryPointTagsT>(value);
  }
  template <typename RecoveryPointTagsT = Aws::Map<Aws::String, Aws::String>>
  StartBackupJobRequest& WithRecoveryPointTags(RecoveryPointTagsT&& value) {
    SetRecoveryPointTags(std::forward<RecoveryPointTagsT>(value));
    return *this;
  }
  template <typename RecoveryPointTagsKeyT = Aws::String, typename RecoveryPointTagsValueT = Aws::String>
  StartBackupJobRequest& AddRecoveryPointTags(RecoveryPointTagsKeyT&& key, RecoveryPointTagsValueT&& value) {
    m_recoveryPointTagsHasBeenSet = true;
    m_recoveryPointTags.emplace(std::forward<RecoveryPointTagsKeyT>(key), std::forward<RecoveryPointTagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetBackupOptions() const { return m_backupOptions; }
  inline bool BackupOptionsHasBeenSet() const { return m_backupOptionsHasBeenSet; }
  template <typename BackupOptionsT = Aws::Map<Aws::String, Aws::String>>
  void SetBackupOptions(BackupOptionsT&& value) {
    m_backupOptionsHasBeenSet = true;
    m_backupOptions = std::forward<BackupOptionsT>(value);
  }
  template <typename BackupOptionsT = Aws::Map<Aws::String, Aws::String>>
  StartBackupJobRequest& WithBackupOptions(BackupOptionsT&& value) {
    SetBackupOptions(std::forward<BackupOptionsT>(value));
    return *this;
  }
  template <typename BackupOptionsKeyT = Aws::String, typename BackupOptionsValueT = Aws::String>
  StartBackupJobRequest& AddBackupOptions(BackupOptionsKeyT&& key, BackupOptionsValueT&& value) {
    m_backupOptionsHasBeenSet = true;
    m_backupOptions.emplace(std::forward<BackupOptionsKeyT>(key), std::forward<BackupOptionsValueT>(value));
    return *this;
  }
 
 
  inline Index GetIndex() const { return m_index; }
  inline bool IndexHasBeenSet() const { return m_indexHasBeenSet; }
  inline void SetIndex(Index value) {
    m_indexHasBeenSet = true;
    m_index = value;
  }
  inline StartBackupJobRequest& WithIndex(Index value) {
    SetIndex(value);
    return *this;
  }
 private:
  Aws::String m_backupVaultName;
 
  Aws::String m_logicallyAirGappedBackupVaultArn;
 
  Aws::String m_resourceArn;
 
  Aws::String m_iamRoleArn;
 
  Aws::String m_idempotencyToken{Aws::Utils::UUID::PseudoRandomUUID()};
 
  long long m_startWindowMinutes{0};
 
  long long m_completeWindowMinutes{0};
 
  Lifecycle m_lifecycle;
 
  Aws::Map<Aws::String, Aws::String> m_recoveryPointTags;
 
  Aws::Map<Aws::String, Aws::String> m_backupOptions;
 
  Index m_index{Index::NOT_SET};
  bool m_backupVaultNameHasBeenSet = false;
  bool m_logicallyAirGappedBackupVaultArnHasBeenSet = false;
  bool m_resourceArnHasBeenSet = false;
  bool m_iamRoleArnHasBeenSet = false;
  bool m_idempotencyTokenHasBeenSet = true;
  bool m_startWindowMinutesHasBeenSet = false;
  bool m_completeWindowMinutesHasBeenSet = false;
  bool m_lifecycleHasBeenSet = false;
  bool m_recoveryPointTagsHasBeenSet = false;
  bool m_backupOptionsHasBeenSet = false;
  bool m_indexHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Backup
}  // namespace Aws