ScalingPolicy.h

 
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/autoscaling/model/Alarm.h>
#include <aws/autoscaling/model/PredictiveScalingConfiguration.h>
#include <aws/autoscaling/model/StepAdjustment.h>
#include <aws/autoscaling/model/TargetTrackingConfiguration.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace AutoScaling {
namespace Model {
 
class ScalingPolicy {
 public:
  AWS_AUTOSCALING_API ScalingPolicy() = default;
  AWS_AUTOSCALING_API ScalingPolicy(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_AUTOSCALING_API ScalingPolicy& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_AUTOSCALING_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetAutoScalingGroupName() const { return m_autoScalingGroupName; }
  inline bool AutoScalingGroupNameHasBeenSet() const { return m_autoScalingGroupNameHasBeenSet; }
  template <typename AutoScalingGroupNameT = Aws::String>
  void SetAutoScalingGroupName(AutoScalingGroupNameT&& value) {
    m_autoScalingGroupNameHasBeenSet = true;
    m_autoScalingGroupName = std::forward<AutoScalingGroupNameT>(value);
  }
  template <typename AutoScalingGroupNameT = Aws::String>
  ScalingPolicy& WithAutoScalingGroupName(AutoScalingGroupNameT&& value) {
    SetAutoScalingGroupName(std::forward<AutoScalingGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicyName() const { return m_policyName; }
  inline bool PolicyNameHasBeenSet() const { return m_policyNameHasBeenSet; }
  template <typename PolicyNameT = Aws::String>
  void SetPolicyName(PolicyNameT&& value) {
    m_policyNameHasBeenSet = true;
    m_policyName = std::forward<PolicyNameT>(value);
  }
  template <typename PolicyNameT = Aws::String>
  ScalingPolicy& WithPolicyName(PolicyNameT&& value) {
    SetPolicyName(std::forward<PolicyNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicyARN() const { return m_policyARN; }
  inline bool PolicyARNHasBeenSet() const { return m_policyARNHasBeenSet; }
  template <typename PolicyARNT = Aws::String>
  void SetPolicyARN(PolicyARNT&& value) {
    m_policyARNHasBeenSet = true;
    m_policyARN = std::forward<PolicyARNT>(value);
  }
  template <typename PolicyARNT = Aws::String>
  ScalingPolicy& WithPolicyARN(PolicyARNT&& value) {
    SetPolicyARN(std::forward<PolicyARNT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPolicyType() const { return m_policyType; }
  inline bool PolicyTypeHasBeenSet() const { return m_policyTypeHasBeenSet; }
  template <typename PolicyTypeT = Aws::String>
  void SetPolicyType(PolicyTypeT&& value) {
    m_policyTypeHasBeenSet = true;
    m_policyType = std::forward<PolicyTypeT>(value);
  }
  template <typename PolicyTypeT = Aws::String>
  ScalingPolicy& WithPolicyType(PolicyTypeT&& value) {
    SetPolicyType(std::forward<PolicyTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAdjustmentType() const { return m_adjustmentType; }
  inline bool AdjustmentTypeHasBeenSet() const { return m_adjustmentTypeHasBeenSet; }
  template <typename AdjustmentTypeT = Aws::String>
  void SetAdjustmentType(AdjustmentTypeT&& value) {
    m_adjustmentTypeHasBeenSet = true;
    m_adjustmentType = std::forward<AdjustmentTypeT>(value);
  }
  template <typename AdjustmentTypeT = Aws::String>
  ScalingPolicy& WithAdjustmentType(AdjustmentTypeT&& value) {
    SetAdjustmentType(std::forward<AdjustmentTypeT>(value));
    return *this;
  }
 
 
  inline int GetMinAdjustmentStep() const { return m_minAdjustmentStep; }
  inline bool MinAdjustmentStepHasBeenSet() const { return m_minAdjustmentStepHasBeenSet; }
  inline void SetMinAdjustmentStep(int value) {
    m_minAdjustmentStepHasBeenSet = true;
    m_minAdjustmentStep = value;
  }
  inline ScalingPolicy& WithMinAdjustmentStep(int value) {
    SetMinAdjustmentStep(value);
    return *this;
  }
 
 
  inline int GetMinAdjustmentMagnitude() const { return m_minAdjustmentMagnitude; }
  inline bool MinAdjustmentMagnitudeHasBeenSet() const { return m_minAdjustmentMagnitudeHasBeenSet; }
  inline void SetMinAdjustmentMagnitude(int value) {
    m_minAdjustmentMagnitudeHasBeenSet = true;
    m_minAdjustmentMagnitude = value;
  }
  inline ScalingPolicy& WithMinAdjustmentMagnitude(int value) {
    SetMinAdjustmentMagnitude(value);
    return *this;
  }
 
 
  inline int GetScalingAdjustment() const { return m_scalingAdjustment; }
  inline bool ScalingAdjustmentHasBeenSet() const { return m_scalingAdjustmentHasBeenSet; }
  inline void SetScalingAdjustment(int value) {
    m_scalingAdjustmentHasBeenSet = true;
    m_scalingAdjustment = value;
  }
  inline ScalingPolicy& WithScalingAdjustment(int value) {
    SetScalingAdjustment(value);
    return *this;
  }
 
 
  inline int GetCooldown() const { return m_cooldown; }
  inline bool CooldownHasBeenSet() const { return m_cooldownHasBeenSet; }
  inline void SetCooldown(int value) {
    m_cooldownHasBeenSet = true;
    m_cooldown = value;
  }
  inline ScalingPolicy& WithCooldown(int value) {
    SetCooldown(value);
    return *this;
  }
 
 
  inline const Aws::Vector<StepAdjustment>& GetStepAdjustments() const { return m_stepAdjustments; }
  inline bool StepAdjustmentsHasBeenSet() const { return m_stepAdjustmentsHasBeenSet; }
  template <typename StepAdjustmentsT = Aws::Vector<StepAdjustment>>
  void SetStepAdjustments(StepAdjustmentsT&& value) {
    m_stepAdjustmentsHasBeenSet = true;
    m_stepAdjustments = std::forward<StepAdjustmentsT>(value);
  }
  template <typename StepAdjustmentsT = Aws::Vector<StepAdjustment>>
  ScalingPolicy& WithStepAdjustments(StepAdjustmentsT&& value) {
    SetStepAdjustments(std::forward<StepAdjustmentsT>(value));
    return *this;
  }
  template <typename StepAdjustmentsT = StepAdjustment>
  ScalingPolicy& AddStepAdjustments(StepAdjustmentsT&& value) {
    m_stepAdjustmentsHasBeenSet = true;
    m_stepAdjustments.emplace_back(std::forward<StepAdjustmentsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMetricAggregationType() const { return m_metricAggregationType; }
  inline bool MetricAggregationTypeHasBeenSet() const { return m_metricAggregationTypeHasBeenSet; }
  template <typename MetricAggregationTypeT = Aws::String>
  void SetMetricAggregationType(MetricAggregationTypeT&& value) {
    m_metricAggregationTypeHasBeenSet = true;
    m_metricAggregationType = std::forward<MetricAggregationTypeT>(value);
  }
  template <typename MetricAggregationTypeT = Aws::String>
  ScalingPolicy& WithMetricAggregationType(MetricAggregationTypeT&& value) {
    SetMetricAggregationType(std::forward<MetricAggregationTypeT>(value));
    return *this;
  }
 
 
  inline int GetEstimatedInstanceWarmup() const { return m_estimatedInstanceWarmup; }
  inline bool EstimatedInstanceWarmupHasBeenSet() const { return m_estimatedInstanceWarmupHasBeenSet; }
  inline void SetEstimatedInstanceWarmup(int value) {
    m_estimatedInstanceWarmupHasBeenSet = true;
    m_estimatedInstanceWarmup = value;
  }
  inline ScalingPolicy& WithEstimatedInstanceWarmup(int value) {
    SetEstimatedInstanceWarmup(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Alarm>& GetAlarms() const { return m_alarms; }
  inline bool AlarmsHasBeenSet() const { return m_alarmsHasBeenSet; }
  template <typename AlarmsT = Aws::Vector<Alarm>>
  void SetAlarms(AlarmsT&& value) {
    m_alarmsHasBeenSet = true;
    m_alarms = std::forward<AlarmsT>(value);
  }
  template <typename AlarmsT = Aws::Vector<Alarm>>
  ScalingPolicy& WithAlarms(AlarmsT&& value) {
    SetAlarms(std::forward<AlarmsT>(value));
    return *this;
  }
  template <typename AlarmsT = Alarm>
  ScalingPolicy& AddAlarms(AlarmsT&& value) {
    m_alarmsHasBeenSet = true;
    m_alarms.emplace_back(std::forward<AlarmsT>(value));
    return *this;
  }
 
 
  inline const TargetTrackingConfiguration& GetTargetTrackingConfiguration() const { return m_targetTrackingConfiguration; }
  inline bool TargetTrackingConfigurationHasBeenSet() const { return m_targetTrackingConfigurationHasBeenSet; }
  template <typename TargetTrackingConfigurationT = TargetTrackingConfiguration>
  void SetTargetTrackingConfiguration(TargetTrackingConfigurationT&& value) {
    m_targetTrackingConfigurationHasBeenSet = true;
    m_targetTrackingConfiguration = std::forward<TargetTrackingConfigurationT>(value);
  }
  template <typename TargetTrackingConfigurationT = TargetTrackingConfiguration>
  ScalingPolicy& WithTargetTrackingConfiguration(TargetTrackingConfigurationT&& value) {
    SetTargetTrackingConfiguration(std::forward<TargetTrackingConfigurationT>(value));
    return *this;
  }
 
 
  inline bool GetEnabled() const { return m_enabled; }
  inline bool EnabledHasBeenSet() const { return m_enabledHasBeenSet; }
  inline void SetEnabled(bool value) {
    m_enabledHasBeenSet = true;
    m_enabled = value;
  }
  inline ScalingPolicy& WithEnabled(bool value) {
    SetEnabled(value);
    return *this;
  }
 
 
  inline const PredictiveScalingConfiguration& GetPredictiveScalingConfiguration() const { return m_predictiveScalingConfiguration; }
  inline bool PredictiveScalingConfigurationHasBeenSet() const { return m_predictiveScalingConfigurationHasBeenSet; }
  template <typename PredictiveScalingConfigurationT = PredictiveScalingConfiguration>
  void SetPredictiveScalingConfiguration(PredictiveScalingConfigurationT&& value) {
    m_predictiveScalingConfigurationHasBeenSet = true;
    m_predictiveScalingConfiguration = std::forward<PredictiveScalingConfigurationT>(value);
  }
  template <typename PredictiveScalingConfigurationT = PredictiveScalingConfiguration>
  ScalingPolicy& WithPredictiveScalingConfiguration(PredictiveScalingConfigurationT&& value) {
    SetPredictiveScalingConfiguration(std::forward<PredictiveScalingConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_autoScalingGroupName;
 
  Aws::String m_policyName;
 
  Aws::String m_policyARN;
 
  Aws::String m_policyType;
 
  Aws::String m_adjustmentType;
 
  int m_minAdjustmentStep{0};
 
  int m_minAdjustmentMagnitude{0};
 
  int m_scalingAdjustment{0};
 
  int m_cooldown{0};
 
  Aws::Vector<StepAdjustment> m_stepAdjustments;
 
  Aws::String m_metricAggregationType;
 
  int m_estimatedInstanceWarmup{0};
 
  Aws::Vector<Alarm> m_alarms;
 
  TargetTrackingConfiguration m_targetTrackingConfiguration;
 
  bool m_enabled{false};
 
  PredictiveScalingConfiguration m_predictiveScalingConfiguration;
  bool m_autoScalingGroupNameHasBeenSet = false;
  bool m_policyNameHasBeenSet = false;
  bool m_policyARNHasBeenSet = false;
  bool m_policyTypeHasBeenSet = false;
  bool m_adjustmentTypeHasBeenSet = false;
  bool m_minAdjustmentStepHasBeenSet = false;
  bool m_minAdjustmentMagnitudeHasBeenSet = false;
  bool m_scalingAdjustmentHasBeenSet = false;
  bool m_cooldownHasBeenSet = false;
  bool m_stepAdjustmentsHasBeenSet = false;
  bool m_metricAggregationTypeHasBeenSet = false;
  bool m_estimatedInstanceWarmupHasBeenSet = false;
  bool m_alarmsHasBeenSet = false;
  bool m_targetTrackingConfigurationHasBeenSet = false;
  bool m_enabledHasBeenSet = false;
  bool m_predictiveScalingConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AutoScaling
}  // namespace Aws