PutScalingPolicyRequest.h

 
#pragma once
#include <aws/autoscaling/AutoScalingRequest.h>
#include <aws/autoscaling/AutoScaling_EXPORTS.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/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace AutoScaling {
namespace Model {
 
class PutScalingPolicyRequest : public AutoScalingRequest {
 public:
  AWS_AUTOSCALING_API PutScalingPolicyRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "PutScalingPolicy"; }
 
  AWS_AUTOSCALING_API Aws::String SerializePayload() const override;
 
 protected:
  AWS_AUTOSCALING_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;
 
 public:
 
  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>
  PutScalingPolicyRequest& 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>
  PutScalingPolicyRequest& WithPolicyName(PolicyNameT&& value) {
    SetPolicyName(std::forward<PolicyNameT>(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>
  PutScalingPolicyRequest& 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>
  PutScalingPolicyRequest& 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 PutScalingPolicyRequest& 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 PutScalingPolicyRequest& 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 PutScalingPolicyRequest& 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 PutScalingPolicyRequest& WithCooldown(int value) {
    SetCooldown(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>
  PutScalingPolicyRequest& WithMetricAggregationType(MetricAggregationTypeT&& value) {
    SetMetricAggregationType(std::forward<MetricAggregationTypeT>(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>>
  PutScalingPolicyRequest& WithStepAdjustments(StepAdjustmentsT&& value) {
    SetStepAdjustments(std::forward<StepAdjustmentsT>(value));
    return *this;
  }
  template <typename StepAdjustmentsT = StepAdjustment>
  PutScalingPolicyRequest& AddStepAdjustments(StepAdjustmentsT&& value) {
    m_stepAdjustmentsHasBeenSet = true;
    m_stepAdjustments.emplace_back(std::forward<StepAdjustmentsT>(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 PutScalingPolicyRequest& WithEstimatedInstanceWarmup(int value) {
    SetEstimatedInstanceWarmup(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>
  PutScalingPolicyRequest& 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 PutScalingPolicyRequest& 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>
  PutScalingPolicyRequest& WithPredictiveScalingConfiguration(PredictiveScalingConfigurationT&& value) {
    SetPredictiveScalingConfiguration(std::forward<PredictiveScalingConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_autoScalingGroupName;
 
  Aws::String m_policyName;
 
  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::String m_metricAggregationType;
 
  Aws::Vector<StepAdjustment> m_stepAdjustments;
 
  int m_estimatedInstanceWarmup{0};
 
  TargetTrackingConfiguration m_targetTrackingConfiguration;
 
  bool m_enabled{false};
 
  PredictiveScalingConfiguration m_predictiveScalingConfiguration;
  bool m_autoScalingGroupNameHasBeenSet = false;
  bool m_policyNameHasBeenSet = 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_metricAggregationTypeHasBeenSet = false;
  bool m_stepAdjustmentsHasBeenSet = false;
  bool m_estimatedInstanceWarmupHasBeenSet = false;
  bool m_targetTrackingConfigurationHasBeenSet = false;
  bool m_enabledHasBeenSet = false;
  bool m_predictiveScalingConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AutoScaling
}  // namespace Aws