PolicyDetails.h

 
#pragma once
#include <aws/dlm/DLM_EXPORTS.h>
#include <aws/dlm/model/PolicyTypeValues.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/dlm/model/Parameters.h>
#include <aws/dlm/model/EventSource.h>
#include <aws/dlm/model/PolicyLanguageValues.h>
#include <aws/dlm/model/ResourceTypeValues.h>
#include <aws/dlm/model/Exclusions.h>
#include <aws/dlm/model/ResourceLocationValues.h>
#include <aws/dlm/model/Tag.h>
#include <aws/dlm/model/Schedule.h>
#include <aws/dlm/model/Action.h>
#include <aws/dlm/model/CrossRegionCopyTarget.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};
    bool m_policyTypeHasBeenSet = false;
 
    Aws::Vector<ResourceTypeValues> m_resourceTypes;
    bool m_resourceTypesHasBeenSet = false;
 
    Aws::Vector<ResourceLocationValues> m_resourceLocations;
    bool m_resourceLocationsHasBeenSet = false;
 
    Aws::Vector<Tag> m_targetTags;
    bool m_targetTagsHasBeenSet = false;
 
    Aws::Vector<Schedule> m_schedules;
    bool m_schedulesHasBeenSet = false;
 
    Parameters m_parameters;
    bool m_parametersHasBeenSet = false;
 
    EventSource m_eventSource;
    bool m_eventSourceHasBeenSet = false;
 
    Aws::Vector<Action> m_actions;
    bool m_actionsHasBeenSet = false;
 
    PolicyLanguageValues m_policyLanguage{PolicyLanguageValues::NOT_SET};
    bool m_policyLanguageHasBeenSet = false;
 
    ResourceTypeValues m_resourceType{ResourceTypeValues::NOT_SET};
    bool m_resourceTypeHasBeenSet = false;
 
    int m_createInterval{0};
    bool m_createIntervalHasBeenSet = false;
 
    int m_retainInterval{0};
    bool m_retainIntervalHasBeenSet = false;
 
    bool m_copyTags{false};
    bool m_copyTagsHasBeenSet = false;
 
    Aws::Vector<CrossRegionCopyTarget> m_crossRegionCopyTargets;
    bool m_crossRegionCopyTargetsHasBeenSet = false;
 
    bool m_extendDeletion{false};
    bool m_extendDeletionHasBeenSet = false;
 
    Exclusions m_exclusions;
    bool m_exclusionsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace DLM
} // namespace Aws