Schedule.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/dlm/DLM_EXPORTS.h>
#include <aws/dlm/model/ArchiveRule.h>
#include <aws/dlm/model/CreateRule.h>
#include <aws/dlm/model/CrossRegionCopyRule.h>
#include <aws/dlm/model/DeprecateRule.h>
#include <aws/dlm/model/FastRestoreRule.h>
#include <aws/dlm/model/RetainRule.h>
#include <aws/dlm/model/ShareRule.h>
#include <aws/dlm/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DLM {
namespace Model {
 
class Schedule {
 public:
  AWS_DLM_API Schedule() = default;
  AWS_DLM_API Schedule(Aws::Utils::Json::JsonView jsonValue);
  AWS_DLM_API Schedule& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DLM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  Schedule& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline bool GetCopyTags() const { return m_copyTags; }
  inline bool CopyTagsHasBeenSet() const { return m_copyTagsHasBeenSet; }
  inline void SetCopyTags(bool value) {
    m_copyTagsHasBeenSet = true;
    m_copyTags = value;
  }
  inline Schedule& WithCopyTags(bool value) {
    SetCopyTags(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTagsToAdd() const { return m_tagsToAdd; }
  inline bool TagsToAddHasBeenSet() const { return m_tagsToAddHasBeenSet; }
  template <typename TagsToAddT = Aws::Vector<Tag>>
  void SetTagsToAdd(TagsToAddT&& value) {
    m_tagsToAddHasBeenSet = true;
    m_tagsToAdd = std::forward<TagsToAddT>(value);
  }
  template <typename TagsToAddT = Aws::Vector<Tag>>
  Schedule& WithTagsToAdd(TagsToAddT&& value) {
    SetTagsToAdd(std::forward<TagsToAddT>(value));
    return *this;
  }
  template <typename TagsToAddT = Tag>
  Schedule& AddTagsToAdd(TagsToAddT&& value) {
    m_tagsToAddHasBeenSet = true;
    m_tagsToAdd.emplace_back(std::forward<TagsToAddT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetVariableTags() const { return m_variableTags; }
  inline bool VariableTagsHasBeenSet() const { return m_variableTagsHasBeenSet; }
  template <typename VariableTagsT = Aws::Vector<Tag>>
  void SetVariableTags(VariableTagsT&& value) {
    m_variableTagsHasBeenSet = true;
    m_variableTags = std::forward<VariableTagsT>(value);
  }
  template <typename VariableTagsT = Aws::Vector<Tag>>
  Schedule& WithVariableTags(VariableTagsT&& value) {
    SetVariableTags(std::forward<VariableTagsT>(value));
    return *this;
  }
  template <typename VariableTagsT = Tag>
  Schedule& AddVariableTags(VariableTagsT&& value) {
    m_variableTagsHasBeenSet = true;
    m_variableTags.emplace_back(std::forward<VariableTagsT>(value));
    return *this;
  }
 
 
  inline const CreateRule& GetCreateRule() const { return m_createRule; }
  inline bool CreateRuleHasBeenSet() const { return m_createRuleHasBeenSet; }
  template <typename CreateRuleT = CreateRule>
  void SetCreateRule(CreateRuleT&& value) {
    m_createRuleHasBeenSet = true;
    m_createRule = std::forward<CreateRuleT>(value);
  }
  template <typename CreateRuleT = CreateRule>
  Schedule& WithCreateRule(CreateRuleT&& value) {
    SetCreateRule(std::forward<CreateRuleT>(value));
    return *this;
  }
 
 
  inline const RetainRule& GetRetainRule() const { return m_retainRule; }
  inline bool RetainRuleHasBeenSet() const { return m_retainRuleHasBeenSet; }
  template <typename RetainRuleT = RetainRule>
  void SetRetainRule(RetainRuleT&& value) {
    m_retainRuleHasBeenSet = true;
    m_retainRule = std::forward<RetainRuleT>(value);
  }
  template <typename RetainRuleT = RetainRule>
  Schedule& WithRetainRule(RetainRuleT&& value) {
    SetRetainRule(std::forward<RetainRuleT>(value));
    return *this;
  }
 
 
  inline const FastRestoreRule& GetFastRestoreRule() const { return m_fastRestoreRule; }
  inline bool FastRestoreRuleHasBeenSet() const { return m_fastRestoreRuleHasBeenSet; }
  template <typename FastRestoreRuleT = FastRestoreRule>
  void SetFastRestoreRule(FastRestoreRuleT&& value) {
    m_fastRestoreRuleHasBeenSet = true;
    m_fastRestoreRule = std::forward<FastRestoreRuleT>(value);
  }
  template <typename FastRestoreRuleT = FastRestoreRule>
  Schedule& WithFastRestoreRule(FastRestoreRuleT&& value) {
    SetFastRestoreRule(std::forward<FastRestoreRuleT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CrossRegionCopyRule>& GetCrossRegionCopyRules() const { return m_crossRegionCopyRules; }
  inline bool CrossRegionCopyRulesHasBeenSet() const { return m_crossRegionCopyRulesHasBeenSet; }
  template <typename CrossRegionCopyRulesT = Aws::Vector<CrossRegionCopyRule>>
  void SetCrossRegionCopyRules(CrossRegionCopyRulesT&& value) {
    m_crossRegionCopyRulesHasBeenSet = true;
    m_crossRegionCopyRules = std::forward<CrossRegionCopyRulesT>(value);
  }
  template <typename CrossRegionCopyRulesT = Aws::Vector<CrossRegionCopyRule>>
  Schedule& WithCrossRegionCopyRules(CrossRegionCopyRulesT&& value) {
    SetCrossRegionCopyRules(std::forward<CrossRegionCopyRulesT>(value));
    return *this;
  }
  template <typename CrossRegionCopyRulesT = CrossRegionCopyRule>
  Schedule& AddCrossRegionCopyRules(CrossRegionCopyRulesT&& value) {
    m_crossRegionCopyRulesHasBeenSet = true;
    m_crossRegionCopyRules.emplace_back(std::forward<CrossRegionCopyRulesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ShareRule>& GetShareRules() const { return m_shareRules; }
  inline bool ShareRulesHasBeenSet() const { return m_shareRulesHasBeenSet; }
  template <typename ShareRulesT = Aws::Vector<ShareRule>>
  void SetShareRules(ShareRulesT&& value) {
    m_shareRulesHasBeenSet = true;
    m_shareRules = std::forward<ShareRulesT>(value);
  }
  template <typename ShareRulesT = Aws::Vector<ShareRule>>
  Schedule& WithShareRules(ShareRulesT&& value) {
    SetShareRules(std::forward<ShareRulesT>(value));
    return *this;
  }
  template <typename ShareRulesT = ShareRule>
  Schedule& AddShareRules(ShareRulesT&& value) {
    m_shareRulesHasBeenSet = true;
    m_shareRules.emplace_back(std::forward<ShareRulesT>(value));
    return *this;
  }
 
 
  inline const DeprecateRule& GetDeprecateRule() const { return m_deprecateRule; }
  inline bool DeprecateRuleHasBeenSet() const { return m_deprecateRuleHasBeenSet; }
  template <typename DeprecateRuleT = DeprecateRule>
  void SetDeprecateRule(DeprecateRuleT&& value) {
    m_deprecateRuleHasBeenSet = true;
    m_deprecateRule = std::forward<DeprecateRuleT>(value);
  }
  template <typename DeprecateRuleT = DeprecateRule>
  Schedule& WithDeprecateRule(DeprecateRuleT&& value) {
    SetDeprecateRule(std::forward<DeprecateRuleT>(value));
    return *this;
  }
 
 
  inline const ArchiveRule& GetArchiveRule() const { return m_archiveRule; }
  inline bool ArchiveRuleHasBeenSet() const { return m_archiveRuleHasBeenSet; }
  template <typename ArchiveRuleT = ArchiveRule>
  void SetArchiveRule(ArchiveRuleT&& value) {
    m_archiveRuleHasBeenSet = true;
    m_archiveRule = std::forward<ArchiveRuleT>(value);
  }
  template <typename ArchiveRuleT = ArchiveRule>
  Schedule& WithArchiveRule(ArchiveRuleT&& value) {
    SetArchiveRule(std::forward<ArchiveRuleT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  bool m_copyTags{false};
 
  Aws::Vector<Tag> m_tagsToAdd;
 
  Aws::Vector<Tag> m_variableTags;
 
  CreateRule m_createRule;
 
  RetainRule m_retainRule;
 
  FastRestoreRule m_fastRestoreRule;
 
  Aws::Vector<CrossRegionCopyRule> m_crossRegionCopyRules;
 
  Aws::Vector<ShareRule> m_shareRules;
 
  DeprecateRule m_deprecateRule;
 
  ArchiveRule m_archiveRule;
  bool m_nameHasBeenSet = false;
  bool m_copyTagsHasBeenSet = false;
  bool m_tagsToAddHasBeenSet = false;
  bool m_variableTagsHasBeenSet = false;
  bool m_createRuleHasBeenSet = false;
  bool m_retainRuleHasBeenSet = false;
  bool m_fastRestoreRuleHasBeenSet = false;
  bool m_crossRegionCopyRulesHasBeenSet = false;
  bool m_shareRulesHasBeenSet = false;
  bool m_deprecateRuleHasBeenSet = false;
  bool m_archiveRuleHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DLM
}  // namespace Aws