BackupRule.h

 
#pragma once
#include <aws/backup/Backup_EXPORTS.h>
#include <aws/backup/model/CopyAction.h>
#include <aws/backup/model/IndexAction.h>
#include <aws/backup/model/Lifecycle.h>
#include <aws/backup/model/ScanAction.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Backup {
namespace Model {
 
class BackupRule {
 public:
  AWS_BACKUP_API BackupRule() = default;
  AWS_BACKUP_API BackupRule(Aws::Utils::Json::JsonView jsonValue);
  AWS_BACKUP_API BackupRule& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BACKUP_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetRuleName() const { return m_ruleName; }
  inline bool RuleNameHasBeenSet() const { return m_ruleNameHasBeenSet; }
  template <typename RuleNameT = Aws::String>
  void SetRuleName(RuleNameT&& value) {
    m_ruleNameHasBeenSet = true;
    m_ruleName = std::forward<RuleNameT>(value);
  }
  template <typename RuleNameT = Aws::String>
  BackupRule& WithRuleName(RuleNameT&& value) {
    SetRuleName(std::forward<RuleNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetBackupVaultName() const { return m_targetBackupVaultName; }
  inline bool TargetBackupVaultNameHasBeenSet() const { return m_targetBackupVaultNameHasBeenSet; }
  template <typename TargetBackupVaultNameT = Aws::String>
  void SetTargetBackupVaultName(TargetBackupVaultNameT&& value) {
    m_targetBackupVaultNameHasBeenSet = true;
    m_targetBackupVaultName = std::forward<TargetBackupVaultNameT>(value);
  }
  template <typename TargetBackupVaultNameT = Aws::String>
  BackupRule& WithTargetBackupVaultName(TargetBackupVaultNameT&& value) {
    SetTargetBackupVaultName(std::forward<TargetBackupVaultNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetLogicallyAirGappedBackupVaultArn() const { return m_targetLogicallyAirGappedBackupVaultArn; }
  inline bool TargetLogicallyAirGappedBackupVaultArnHasBeenSet() const { return m_targetLogicallyAirGappedBackupVaultArnHasBeenSet; }
  template <typename TargetLogicallyAirGappedBackupVaultArnT = Aws::String>
  void SetTargetLogicallyAirGappedBackupVaultArn(TargetLogicallyAirGappedBackupVaultArnT&& value) {
    m_targetLogicallyAirGappedBackupVaultArnHasBeenSet = true;
    m_targetLogicallyAirGappedBackupVaultArn = std::forward<TargetLogicallyAirGappedBackupVaultArnT>(value);
  }
  template <typename TargetLogicallyAirGappedBackupVaultArnT = Aws::String>
  BackupRule& WithTargetLogicallyAirGappedBackupVaultArn(TargetLogicallyAirGappedBackupVaultArnT&& value) {
    SetTargetLogicallyAirGappedBackupVaultArn(std::forward<TargetLogicallyAirGappedBackupVaultArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetScheduleExpression() const { return m_scheduleExpression; }
  inline bool ScheduleExpressionHasBeenSet() const { return m_scheduleExpressionHasBeenSet; }
  template <typename ScheduleExpressionT = Aws::String>
  void SetScheduleExpression(ScheduleExpressionT&& value) {
    m_scheduleExpressionHasBeenSet = true;
    m_scheduleExpression = std::forward<ScheduleExpressionT>(value);
  }
  template <typename ScheduleExpressionT = Aws::String>
  BackupRule& WithScheduleExpression(ScheduleExpressionT&& value) {
    SetScheduleExpression(std::forward<ScheduleExpressionT>(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 BackupRule& WithStartWindowMinutes(long long value) {
    SetStartWindowMinutes(value);
    return *this;
  }
 
 
  inline long long GetCompletionWindowMinutes() const { return m_completionWindowMinutes; }
  inline bool CompletionWindowMinutesHasBeenSet() const { return m_completionWindowMinutesHasBeenSet; }
  inline void SetCompletionWindowMinutes(long long value) {
    m_completionWindowMinutesHasBeenSet = true;
    m_completionWindowMinutes = value;
  }
  inline BackupRule& WithCompletionWindowMinutes(long long value) {
    SetCompletionWindowMinutes(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>
  BackupRule& 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>>
  BackupRule& WithRecoveryPointTags(RecoveryPointTagsT&& value) {
    SetRecoveryPointTags(std::forward<RecoveryPointTagsT>(value));
    return *this;
  }
  template <typename RecoveryPointTagsKeyT = Aws::String, typename RecoveryPointTagsValueT = Aws::String>
  BackupRule& AddRecoveryPointTags(RecoveryPointTagsKeyT&& key, RecoveryPointTagsValueT&& value) {
    m_recoveryPointTagsHasBeenSet = true;
    m_recoveryPointTags.emplace(std::forward<RecoveryPointTagsKeyT>(key), std::forward<RecoveryPointTagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRuleId() const { return m_ruleId; }
  inline bool RuleIdHasBeenSet() const { return m_ruleIdHasBeenSet; }
  template <typename RuleIdT = Aws::String>
  void SetRuleId(RuleIdT&& value) {
    m_ruleIdHasBeenSet = true;
    m_ruleId = std::forward<RuleIdT>(value);
  }
  template <typename RuleIdT = Aws::String>
  BackupRule& WithRuleId(RuleIdT&& value) {
    SetRuleId(std::forward<RuleIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CopyAction>& GetCopyActions() const { return m_copyActions; }
  inline bool CopyActionsHasBeenSet() const { return m_copyActionsHasBeenSet; }
  template <typename CopyActionsT = Aws::Vector<CopyAction>>
  void SetCopyActions(CopyActionsT&& value) {
    m_copyActionsHasBeenSet = true;
    m_copyActions = std::forward<CopyActionsT>(value);
  }
  template <typename CopyActionsT = Aws::Vector<CopyAction>>
  BackupRule& WithCopyActions(CopyActionsT&& value) {
    SetCopyActions(std::forward<CopyActionsT>(value));
    return *this;
  }
  template <typename CopyActionsT = CopyAction>
  BackupRule& AddCopyActions(CopyActionsT&& value) {
    m_copyActionsHasBeenSet = true;
    m_copyActions.emplace_back(std::forward<CopyActionsT>(value));
    return *this;
  }
 
 
  inline bool GetEnableContinuousBackup() const { return m_enableContinuousBackup; }
  inline bool EnableContinuousBackupHasBeenSet() const { return m_enableContinuousBackupHasBeenSet; }
  inline void SetEnableContinuousBackup(bool value) {
    m_enableContinuousBackupHasBeenSet = true;
    m_enableContinuousBackup = value;
  }
  inline BackupRule& WithEnableContinuousBackup(bool value) {
    SetEnableContinuousBackup(value);
    return *this;
  }
 
 
  inline const Aws::String& GetScheduleExpressionTimezone() const { return m_scheduleExpressionTimezone; }
  inline bool ScheduleExpressionTimezoneHasBeenSet() const { return m_scheduleExpressionTimezoneHasBeenSet; }
  template <typename ScheduleExpressionTimezoneT = Aws::String>
  void SetScheduleExpressionTimezone(ScheduleExpressionTimezoneT&& value) {
    m_scheduleExpressionTimezoneHasBeenSet = true;
    m_scheduleExpressionTimezone = std::forward<ScheduleExpressionTimezoneT>(value);
  }
  template <typename ScheduleExpressionTimezoneT = Aws::String>
  BackupRule& WithScheduleExpressionTimezone(ScheduleExpressionTimezoneT&& value) {
    SetScheduleExpressionTimezone(std::forward<ScheduleExpressionTimezoneT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<IndexAction>& GetIndexActions() const { return m_indexActions; }
  inline bool IndexActionsHasBeenSet() const { return m_indexActionsHasBeenSet; }
  template <typename IndexActionsT = Aws::Vector<IndexAction>>
  void SetIndexActions(IndexActionsT&& value) {
    m_indexActionsHasBeenSet = true;
    m_indexActions = std::forward<IndexActionsT>(value);
  }
  template <typename IndexActionsT = Aws::Vector<IndexAction>>
  BackupRule& WithIndexActions(IndexActionsT&& value) {
    SetIndexActions(std::forward<IndexActionsT>(value));
    return *this;
  }
  template <typename IndexActionsT = IndexAction>
  BackupRule& AddIndexActions(IndexActionsT&& value) {
    m_indexActionsHasBeenSet = true;
    m_indexActions.emplace_back(std::forward<IndexActionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ScanAction>& GetScanActions() const { return m_scanActions; }
  inline bool ScanActionsHasBeenSet() const { return m_scanActionsHasBeenSet; }
  template <typename ScanActionsT = Aws::Vector<ScanAction>>
  void SetScanActions(ScanActionsT&& value) {
    m_scanActionsHasBeenSet = true;
    m_scanActions = std::forward<ScanActionsT>(value);
  }
  template <typename ScanActionsT = Aws::Vector<ScanAction>>
  BackupRule& WithScanActions(ScanActionsT&& value) {
    SetScanActions(std::forward<ScanActionsT>(value));
    return *this;
  }
  template <typename ScanActionsT = ScanAction>
  BackupRule& AddScanActions(ScanActionsT&& value) {
    m_scanActionsHasBeenSet = true;
    m_scanActions.emplace_back(std::forward<ScanActionsT>(value));
    return *this;
  }
 private:
  Aws::String m_ruleName;
 
  Aws::String m_targetBackupVaultName;
 
  Aws::String m_targetLogicallyAirGappedBackupVaultArn;
 
  Aws::String m_scheduleExpression;
 
  long long m_startWindowMinutes{0};
 
  long long m_completionWindowMinutes{0};
 
  Lifecycle m_lifecycle;
 
  Aws::Map<Aws::String, Aws::String> m_recoveryPointTags;
 
  Aws::String m_ruleId;
 
  Aws::Vector<CopyAction> m_copyActions;
 
  bool m_enableContinuousBackup{false};
 
  Aws::String m_scheduleExpressionTimezone;
 
  Aws::Vector<IndexAction> m_indexActions;
 
  Aws::Vector<ScanAction> m_scanActions;
  bool m_ruleNameHasBeenSet = false;
  bool m_targetBackupVaultNameHasBeenSet = false;
  bool m_targetLogicallyAirGappedBackupVaultArnHasBeenSet = false;
  bool m_scheduleExpressionHasBeenSet = false;
  bool m_startWindowMinutesHasBeenSet = false;
  bool m_completionWindowMinutesHasBeenSet = false;
  bool m_lifecycleHasBeenSet = false;
  bool m_recoveryPointTagsHasBeenSet = false;
  bool m_ruleIdHasBeenSet = false;
  bool m_copyActionsHasBeenSet = false;
  bool m_enableContinuousBackupHasBeenSet = false;
  bool m_scheduleExpressionTimezoneHasBeenSet = false;
  bool m_indexActionsHasBeenSet = false;
  bool m_scanActionsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Backup
}  // namespace Aws