PolicyDetails.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/dlm/DLM_EXPORTS.h>
#include <aws/dlm/model/Action.h>
#include <aws/dlm/model/CrossRegionCopyTarget.h>
#include <aws/dlm/model/EventSource.h>
#include <aws/dlm/model/Exclusions.h>
#include <aws/dlm/model/Parameters.h>
#include <aws/dlm/model/PolicyLanguageValues.h>
#include <aws/dlm/model/PolicyTypeValues.h>
#include <aws/dlm/model/ResourceLocationValues.h>
#include <aws/dlm/model/ResourceTypeValues.h>
#include <aws/dlm/model/Schedule.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 PolicyDetails {
 public:
  AWS_DLM_API PolicyDetails() = default;
  AWS_DLM_API PolicyDetails(Aws::Utils::Json::JsonView jsonValue);
  AWS_DLM_API PolicyDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DLM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline PolicyTypeValues GetPolicyType() const { return m_policyType; }
  inline bool PolicyTypeHasBeenSet() const { return m_policyTypeHasBeenSet; }
  inline void SetPolicyType(PolicyTypeValues value) {
    m_policyTypeHasBeenSet = true;
    m_policyType = value;
  }
  inline PolicyDetails& WithPolicyType(PolicyTypeValues value) {
    SetPolicyType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ResourceTypeValues>& GetResourceTypes() const { return m_resourceTypes; }
  inline bool ResourceTypesHasBeenSet() const { return m_resourceTypesHasBeenSet; }
  template <typename ResourceTypesT = Aws::Vector<ResourceTypeValues>>
  void SetResourceTypes(ResourceTypesT&& value) {
    m_resourceTypesHasBeenSet = true;
    m_resourceTypes = std::forward<ResourceTypesT>(value);
  }
  template <typename ResourceTypesT = Aws::Vector<ResourceTypeValues>>
  PolicyDetails& WithResourceTypes(ResourceTypesT&& value) {
    SetResourceTypes(std::forward<ResourceTypesT>(value));
    return *this;
  }
  inline PolicyDetails& AddResourceTypes(ResourceTypeValues value) {
    m_resourceTypesHasBeenSet = true;
    m_resourceTypes.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ResourceLocationValues>& GetResourceLocations() const { return m_resourceLocations; }
  inline bool ResourceLocationsHasBeenSet() const { return m_resourceLocationsHasBeenSet; }
  template <typename ResourceLocationsT = Aws::Vector<ResourceLocationValues>>
  void SetResourceLocations(ResourceLocationsT&& value) {
    m_resourceLocationsHasBeenSet = true;
    m_resourceLocations = std::forward<ResourceLocationsT>(value);
  }
  template <typename ResourceLocationsT = Aws::Vector<ResourceLocationValues>>
  PolicyDetails& WithResourceLocations(ResourceLocationsT&& value) {
    SetResourceLocations(std::forward<ResourceLocationsT>(value));
    return *this;
  }
  inline PolicyDetails& AddResourceLocations(ResourceLocationValues value) {
    m_resourceLocationsHasBeenSet = true;
    m_resourceLocations.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTargetTags() const { return m_targetTags; }
  inline bool TargetTagsHasBeenSet() const { return m_targetTagsHasBeenSet; }
  template <typename TargetTagsT = Aws::Vector<Tag>>
  void SetTargetTags(TargetTagsT&& value) {
    m_targetTagsHasBeenSet = true;
    m_targetTags = std::forward<TargetTagsT>(value);
  }
  template <typename TargetTagsT = Aws::Vector<Tag>>
  PolicyDetails& WithTargetTags(TargetTagsT&& value) {
    SetTargetTags(std::forward<TargetTagsT>(value));
    return *this;
  }
  template <typename TargetTagsT = Tag>
  PolicyDetails& AddTargetTags(TargetTagsT&& value) {
    m_targetTagsHasBeenSet = true;
    m_targetTags.emplace_back(std::forward<TargetTagsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Schedule>& GetSchedules() const { return m_schedules; }
  inline bool SchedulesHasBeenSet() const { return m_schedulesHasBeenSet; }
  template <typename SchedulesT = Aws::Vector<Schedule>>
  void SetSchedules(SchedulesT&& value) {
    m_schedulesHasBeenSet = true;
    m_schedules = std::forward<SchedulesT>(value);
  }
  template <typename SchedulesT = Aws::Vector<Schedule>>
  PolicyDetails& WithSchedules(SchedulesT&& value) {
    SetSchedules(std::forward<SchedulesT>(value));
    return *this;
  }
  template <typename SchedulesT = Schedule>
  PolicyDetails& AddSchedules(SchedulesT&& value) {
    m_schedulesHasBeenSet = true;
    m_schedules.emplace_back(std::forward<SchedulesT>(value));
    return *this;
  }
 
 
  inline const Parameters& GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = Parameters>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = Parameters>
  PolicyDetails& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
 
 
  inline const EventSource& GetEventSource() const { return m_eventSource; }
  inline bool EventSourceHasBeenSet() const { return m_eventSourceHasBeenSet; }
  template <typename EventSourceT = EventSource>
  void SetEventSource(EventSourceT&& value) {
    m_eventSourceHasBeenSet = true;
    m_eventSource = std::forward<EventSourceT>(value);
  }
  template <typename EventSourceT = EventSource>
  PolicyDetails& WithEventSource(EventSourceT&& value) {
    SetEventSource(std::forward<EventSourceT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Action>& GetActions() const { return m_actions; }
  inline bool ActionsHasBeenSet() const { return m_actionsHasBeenSet; }
  template <typename ActionsT = Aws::Vector<Action>>
  void SetActions(ActionsT&& value) {
    m_actionsHasBeenSet = true;
    m_actions = std::forward<ActionsT>(value);
  }
  template <typename ActionsT = Aws::Vector<Action>>
  PolicyDetails& WithActions(ActionsT&& value) {
    SetActions(std::forward<ActionsT>(value));
    return *this;
  }
  template <typename ActionsT = Action>
  PolicyDetails& AddActions(ActionsT&& value) {
    m_actionsHasBeenSet = true;
    m_actions.emplace_back(std::forward<ActionsT>(value));
    return *this;
  }
 
 
  inline PolicyLanguageValues GetPolicyLanguage() const { return m_policyLanguage; }
  inline bool PolicyLanguageHasBeenSet() const { return m_policyLanguageHasBeenSet; }
  inline void SetPolicyLanguage(PolicyLanguageValues value) {
    m_policyLanguageHasBeenSet = true;
    m_policyLanguage = value;
  }
  inline PolicyDetails& WithPolicyLanguage(PolicyLanguageValues value) {
    SetPolicyLanguage(value);
    return *this;
  }
 
 
  inline ResourceTypeValues GetResourceType() const { return m_resourceType; }
  inline bool ResourceTypeHasBeenSet() const { return m_resourceTypeHasBeenSet; }
  inline void SetResourceType(ResourceTypeValues value) {
    m_resourceTypeHasBeenSet = true;
    m_resourceType = value;
  }
  inline PolicyDetails& WithResourceType(ResourceTypeValues value) {
    SetResourceType(value);
    return *this;
  }
 
 
  inline int GetCreateInterval() const { return m_createInterval; }
  inline bool CreateIntervalHasBeenSet() const { return m_createIntervalHasBeenSet; }
  inline void SetCreateInterval(int value) {
    m_createIntervalHasBeenSet = true;
    m_createInterval = value;
  }
  inline PolicyDetails& WithCreateInterval(int value) {
    SetCreateInterval(value);
    return *this;
  }
 
 
  inline int GetRetainInterval() const { return m_retainInterval; }
  inline bool RetainIntervalHasBeenSet() const { return m_retainIntervalHasBeenSet; }
  inline void SetRetainInterval(int value) {
    m_retainIntervalHasBeenSet = true;
    m_retainInterval = value;
  }
  inline PolicyDetails& WithRetainInterval(int value) {
    SetRetainInterval(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 PolicyDetails& WithCopyTags(bool value) {
    SetCopyTags(value);
    return *this;
  }
 
 
  inline const Aws::Vector<CrossRegionCopyTarget>& GetCrossRegionCopyTargets() const { return m_crossRegionCopyTargets; }
  inline bool CrossRegionCopyTargetsHasBeenSet() const { return m_crossRegionCopyTargetsHasBeenSet; }
  template <typename CrossRegionCopyTargetsT = Aws::Vector<CrossRegionCopyTarget>>
  void SetCrossRegionCopyTargets(CrossRegionCopyTargetsT&& value) {
    m_crossRegionCopyTargetsHasBeenSet = true;
    m_crossRegionCopyTargets = std::forward<CrossRegionCopyTargetsT>(value);
  }
  template <typename CrossRegionCopyTargetsT = Aws::Vector<CrossRegionCopyTarget>>
  PolicyDetails& WithCrossRegionCopyTargets(CrossRegionCopyTargetsT&& value) {
    SetCrossRegionCopyTargets(std::forward<CrossRegionCopyTargetsT>(value));
    return *this;
  }
  template <typename CrossRegionCopyTargetsT = CrossRegionCopyTarget>
  PolicyDetails& AddCrossRegionCopyTargets(CrossRegionCopyTargetsT&& value) {
    m_crossRegionCopyTargetsHasBeenSet = true;
    m_crossRegionCopyTargets.emplace_back(std::forward<CrossRegionCopyTargetsT>(value));
    return *this;
  }
 
 
  inline bool GetExtendDeletion() const { return m_extendDeletion; }
  inline bool ExtendDeletionHasBeenSet() const { return m_extendDeletionHasBeenSet; }
  inline void SetExtendDeletion(bool value) {
    m_extendDeletionHasBeenSet = true;
    m_extendDeletion = value;
  }
  inline PolicyDetails& WithExtendDeletion(bool value) {
    SetExtendDeletion(value);
    return *this;
  }
 
 
  inline const Exclusions& GetExclusions() const { return m_exclusions; }
  inline bool ExclusionsHasBeenSet() const { return m_exclusionsHasBeenSet; }
  template <typename ExclusionsT = Exclusions>
  void SetExclusions(ExclusionsT&& value) {
    m_exclusionsHasBeenSet = true;
    m_exclusions = std::forward<ExclusionsT>(value);
  }
  template <typename ExclusionsT = Exclusions>
  PolicyDetails& WithExclusions(ExclusionsT&& value) {
    SetExclusions(std::forward<ExclusionsT>(value));
    return *this;
  }
 private:
  PolicyTypeValues m_policyType{PolicyTypeValues::NOT_SET};
 
  Aws::Vector<ResourceTypeValues> m_resourceTypes;
 
  Aws::Vector<ResourceLocationValues> m_resourceLocations;
 
  Aws::Vector<Tag> m_targetTags;
 
  Aws::Vector<Schedule> m_schedules;
 
  Parameters m_parameters;
 
  EventSource m_eventSource;
 
  Aws::Vector<Action> m_actions;
 
  PolicyLanguageValues m_policyLanguage{PolicyLanguageValues::NOT_SET};
 
  ResourceTypeValues m_resourceType{ResourceTypeValues::NOT_SET};
 
  int m_createInterval{0};
 
  int m_retainInterval{0};
 
  bool m_copyTags{false};
 
  Aws::Vector<CrossRegionCopyTarget> m_crossRegionCopyTargets;
 
  bool m_extendDeletion{false};
 
  Exclusions m_exclusions;
  bool m_policyTypeHasBeenSet = false;
  bool m_resourceTypesHasBeenSet = false;
  bool m_resourceLocationsHasBeenSet = false;
  bool m_targetTagsHasBeenSet = false;
  bool m_schedulesHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_eventSourceHasBeenSet = false;
  bool m_actionsHasBeenSet = false;
  bool m_policyLanguageHasBeenSet = false;
  bool m_resourceTypeHasBeenSet = false;
  bool m_createIntervalHasBeenSet = false;
  bool m_retainIntervalHasBeenSet = false;
  bool m_copyTagsHasBeenSet = false;
  bool m_crossRegionCopyTargetsHasBeenSet = false;
  bool m_extendDeletionHasBeenSet = false;
  bool m_exclusionsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DLM
}  // namespace Aws