RefreshPreferences.h

 
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/autoscaling/model/ScaleInProtectedInstances.h>
#include <aws/autoscaling/model/StandbyInstances.h>
#include <aws/autoscaling/model/AlarmSpecification.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Xml
{
  class XmlNode;
} // namespace Xml
} // namespace Utils
namespace AutoScaling
{
namespace Model
{
 
  class RefreshPreferences
  {
  public:
    AWS_AUTOSCALING_API RefreshPreferences() = default;
    AWS_AUTOSCALING_API RefreshPreferences(const Aws::Utils::Xml::XmlNode& xmlNode);
    AWS_AUTOSCALING_API RefreshPreferences& 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 int GetMinHealthyPercentage() const { return m_minHealthyPercentage; }
    inline bool MinHealthyPercentageHasBeenSet() const { return m_minHealthyPercentageHasBeenSet; }
    inline void SetMinHealthyPercentage(int value) { m_minHealthyPercentageHasBeenSet = true; m_minHealthyPercentage = value; }
    inline RefreshPreferences& WithMinHealthyPercentage(int value) { SetMinHealthyPercentage(value); return *this;}
 
 
    inline int GetInstanceWarmup() const { return m_instanceWarmup; }
    inline bool InstanceWarmupHasBeenSet() const { return m_instanceWarmupHasBeenSet; }
    inline void SetInstanceWarmup(int value) { m_instanceWarmupHasBeenSet = true; m_instanceWarmup = value; }
    inline RefreshPreferences& WithInstanceWarmup(int value) { SetInstanceWarmup(value); return *this;}
 
 
    inline const Aws::Vector<int>& GetCheckpointPercentages() const { return m_checkpointPercentages; }
    inline bool CheckpointPercentagesHasBeenSet() const { return m_checkpointPercentagesHasBeenSet; }
    template<typename CheckpointPercentagesT = Aws::Vector<int>>
    void SetCheckpointPercentages(CheckpointPercentagesT&& value) { m_checkpointPercentagesHasBeenSet = true; m_checkpointPercentages = std::forward<CheckpointPercentagesT>(value); }
    template<typename CheckpointPercentagesT = Aws::Vector<int>>
    RefreshPreferences& WithCheckpointPercentages(CheckpointPercentagesT&& value) { SetCheckpointPercentages(std::forward<CheckpointPercentagesT>(value)); return *this;}
    inline RefreshPreferences& AddCheckpointPercentages(int value) { m_checkpointPercentagesHasBeenSet = true; m_checkpointPercentages.push_back(value); return *this; }
 
 
    inline int GetCheckpointDelay() const { return m_checkpointDelay; }
    inline bool CheckpointDelayHasBeenSet() const { return m_checkpointDelayHasBeenSet; }
    inline void SetCheckpointDelay(int value) { m_checkpointDelayHasBeenSet = true; m_checkpointDelay = value; }
    inline RefreshPreferences& WithCheckpointDelay(int value) { SetCheckpointDelay(value); return *this;}
 
 
    inline bool GetSkipMatching() const { return m_skipMatching; }
    inline bool SkipMatchingHasBeenSet() const { return m_skipMatchingHasBeenSet; }
    inline void SetSkipMatching(bool value) { m_skipMatchingHasBeenSet = true; m_skipMatching = value; }
    inline RefreshPreferences& WithSkipMatching(bool value) { SetSkipMatching(value); return *this;}
 
 
    inline bool GetAutoRollback() const { return m_autoRollback; }
    inline bool AutoRollbackHasBeenSet() const { return m_autoRollbackHasBeenSet; }
    inline void SetAutoRollback(bool value) { m_autoRollbackHasBeenSet = true; m_autoRollback = value; }
    inline RefreshPreferences& WithAutoRollback(bool value) { SetAutoRollback(value); return *this;}
 
 
    inline ScaleInProtectedInstances GetScaleInProtectedInstances() const { return m_scaleInProtectedInstances; }
    inline bool ScaleInProtectedInstancesHasBeenSet() const { return m_scaleInProtectedInstancesHasBeenSet; }
    inline void SetScaleInProtectedInstances(ScaleInProtectedInstances value) { m_scaleInProtectedInstancesHasBeenSet = true; m_scaleInProtectedInstances = value; }
    inline RefreshPreferences& WithScaleInProtectedInstances(ScaleInProtectedInstances value) { SetScaleInProtectedInstances(value); return *this;}
 
 
    inline StandbyInstances GetStandbyInstances() const { return m_standbyInstances; }
    inline bool StandbyInstancesHasBeenSet() const { return m_standbyInstancesHasBeenSet; }
    inline void SetStandbyInstances(StandbyInstances value) { m_standbyInstancesHasBeenSet = true; m_standbyInstances = value; }
    inline RefreshPreferences& WithStandbyInstances(StandbyInstances value) { SetStandbyInstances(value); return *this;}
 
 
    inline const AlarmSpecification& GetAlarmSpecification() const { return m_alarmSpecification; }
    inline bool AlarmSpecificationHasBeenSet() const { return m_alarmSpecificationHasBeenSet; }
    template<typename AlarmSpecificationT = AlarmSpecification>
    void SetAlarmSpecification(AlarmSpecificationT&& value) { m_alarmSpecificationHasBeenSet = true; m_alarmSpecification = std::forward<AlarmSpecificationT>(value); }
    template<typename AlarmSpecificationT = AlarmSpecification>
    RefreshPreferences& WithAlarmSpecification(AlarmSpecificationT&& value) { SetAlarmSpecification(std::forward<AlarmSpecificationT>(value)); return *this;}
 
 
    inline int GetMaxHealthyPercentage() const { return m_maxHealthyPercentage; }
    inline bool MaxHealthyPercentageHasBeenSet() const { return m_maxHealthyPercentageHasBeenSet; }
    inline void SetMaxHealthyPercentage(int value) { m_maxHealthyPercentageHasBeenSet = true; m_maxHealthyPercentage = value; }
    inline RefreshPreferences& WithMaxHealthyPercentage(int value) { SetMaxHealthyPercentage(value); return *this;}
 
 
    inline int GetBakeTime() const { return m_bakeTime; }
    inline bool BakeTimeHasBeenSet() const { return m_bakeTimeHasBeenSet; }
    inline void SetBakeTime(int value) { m_bakeTimeHasBeenSet = true; m_bakeTime = value; }
    inline RefreshPreferences& WithBakeTime(int value) { SetBakeTime(value); return *this;}
  private:
 
    int m_minHealthyPercentage{0};
    bool m_minHealthyPercentageHasBeenSet = false;
 
    int m_instanceWarmup{0};
    bool m_instanceWarmupHasBeenSet = false;
 
    Aws::Vector<int> m_checkpointPercentages;
    bool m_checkpointPercentagesHasBeenSet = false;
 
    int m_checkpointDelay{0};
    bool m_checkpointDelayHasBeenSet = false;
 
    bool m_skipMatching{false};
    bool m_skipMatchingHasBeenSet = false;
 
    bool m_autoRollback{false};
    bool m_autoRollbackHasBeenSet = false;
 
    ScaleInProtectedInstances m_scaleInProtectedInstances{ScaleInProtectedInstances::NOT_SET};
    bool m_scaleInProtectedInstancesHasBeenSet = false;
 
    StandbyInstances m_standbyInstances{StandbyInstances::NOT_SET};
    bool m_standbyInstancesHasBeenSet = false;
 
    AlarmSpecification m_alarmSpecification;
    bool m_alarmSpecificationHasBeenSet = false;
 
    int m_maxHealthyPercentage{0};
    bool m_maxHealthyPercentageHasBeenSet = false;
 
    int m_bakeTime{0};
    bool m_bakeTimeHasBeenSet = false;
  };
 
} // namespace Model
} // namespace AutoScaling
} // namespace Aws