InstanceRefresh.h

 
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/autoscaling/model/DesiredConfiguration.h>
#include <aws/autoscaling/model/InstanceRefreshProgressDetails.h>
#include <aws/autoscaling/model/InstanceRefreshStatus.h>
#include <aws/autoscaling/model/RefreshPreferences.h>
#include <aws/autoscaling/model/RefreshStrategy.h>
#include <aws/autoscaling/model/RollbackDetails.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace AutoScaling {
namespace Model {
 
class InstanceRefresh {
 public:
  AWS_AUTOSCALING_API InstanceRefresh() = default;
  AWS_AUTOSCALING_API InstanceRefresh(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_AUTOSCALING_API InstanceRefresh& 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& GetInstanceRefreshId() const { return m_instanceRefreshId; }
  inline bool InstanceRefreshIdHasBeenSet() const { return m_instanceRefreshIdHasBeenSet; }
  template <typename InstanceRefreshIdT = Aws::String>
  void SetInstanceRefreshId(InstanceRefreshIdT&& value) {
    m_instanceRefreshIdHasBeenSet = true;
    m_instanceRefreshId = std::forward<InstanceRefreshIdT>(value);
  }
  template <typename InstanceRefreshIdT = Aws::String>
  InstanceRefresh& WithInstanceRefreshId(InstanceRefreshIdT&& value) {
    SetInstanceRefreshId(std::forward<InstanceRefreshIdT>(value));
    return *this;
  }
 
 
  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>
  InstanceRefresh& WithAutoScalingGroupName(AutoScalingGroupNameT&& value) {
    SetAutoScalingGroupName(std::forward<AutoScalingGroupNameT>(value));
    return *this;
  }
 
 
  inline InstanceRefreshStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(InstanceRefreshStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline InstanceRefresh& WithStatus(InstanceRefreshStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStatusReason() const { return m_statusReason; }
  inline bool StatusReasonHasBeenSet() const { return m_statusReasonHasBeenSet; }
  template <typename StatusReasonT = Aws::String>
  void SetStatusReason(StatusReasonT&& value) {
    m_statusReasonHasBeenSet = true;
    m_statusReason = std::forward<StatusReasonT>(value);
  }
  template <typename StatusReasonT = Aws::String>
  InstanceRefresh& WithStatusReason(StatusReasonT&& value) {
    SetStatusReason(std::forward<StatusReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStartTime() const { return m_startTime; }
  inline bool StartTimeHasBeenSet() const { return m_startTimeHasBeenSet; }
  template <typename StartTimeT = Aws::Utils::DateTime>
  void SetStartTime(StartTimeT&& value) {
    m_startTimeHasBeenSet = true;
    m_startTime = std::forward<StartTimeT>(value);
  }
  template <typename StartTimeT = Aws::Utils::DateTime>
  InstanceRefresh& WithStartTime(StartTimeT&& value) {
    SetStartTime(std::forward<StartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetEndTime() const { return m_endTime; }
  inline bool EndTimeHasBeenSet() const { return m_endTimeHasBeenSet; }
  template <typename EndTimeT = Aws::Utils::DateTime>
  void SetEndTime(EndTimeT&& value) {
    m_endTimeHasBeenSet = true;
    m_endTime = std::forward<EndTimeT>(value);
  }
  template <typename EndTimeT = Aws::Utils::DateTime>
  InstanceRefresh& WithEndTime(EndTimeT&& value) {
    SetEndTime(std::forward<EndTimeT>(value));
    return *this;
  }
 
 
  inline int GetPercentageComplete() const { return m_percentageComplete; }
  inline bool PercentageCompleteHasBeenSet() const { return m_percentageCompleteHasBeenSet; }
  inline void SetPercentageComplete(int value) {
    m_percentageCompleteHasBeenSet = true;
    m_percentageComplete = value;
  }
  inline InstanceRefresh& WithPercentageComplete(int value) {
    SetPercentageComplete(value);
    return *this;
  }
 
 
  inline int GetInstancesToUpdate() const { return m_instancesToUpdate; }
  inline bool InstancesToUpdateHasBeenSet() const { return m_instancesToUpdateHasBeenSet; }
  inline void SetInstancesToUpdate(int value) {
    m_instancesToUpdateHasBeenSet = true;
    m_instancesToUpdate = value;
  }
  inline InstanceRefresh& WithInstancesToUpdate(int value) {
    SetInstancesToUpdate(value);
    return *this;
  }
 
 
  inline const InstanceRefreshProgressDetails& GetProgressDetails() const { return m_progressDetails; }
  inline bool ProgressDetailsHasBeenSet() const { return m_progressDetailsHasBeenSet; }
  template <typename ProgressDetailsT = InstanceRefreshProgressDetails>
  void SetProgressDetails(ProgressDetailsT&& value) {
    m_progressDetailsHasBeenSet = true;
    m_progressDetails = std::forward<ProgressDetailsT>(value);
  }
  template <typename ProgressDetailsT = InstanceRefreshProgressDetails>
  InstanceRefresh& WithProgressDetails(ProgressDetailsT&& value) {
    SetProgressDetails(std::forward<ProgressDetailsT>(value));
    return *this;
  }
 
 
  inline const RefreshPreferences& GetPreferences() const { return m_preferences; }
  inline bool PreferencesHasBeenSet() const { return m_preferencesHasBeenSet; }
  template <typename PreferencesT = RefreshPreferences>
  void SetPreferences(PreferencesT&& value) {
    m_preferencesHasBeenSet = true;
    m_preferences = std::forward<PreferencesT>(value);
  }
  template <typename PreferencesT = RefreshPreferences>
  InstanceRefresh& WithPreferences(PreferencesT&& value) {
    SetPreferences(std::forward<PreferencesT>(value));
    return *this;
  }
 
 
  inline const DesiredConfiguration& GetDesiredConfiguration() const { return m_desiredConfiguration; }
  inline bool DesiredConfigurationHasBeenSet() const { return m_desiredConfigurationHasBeenSet; }
  template <typename DesiredConfigurationT = DesiredConfiguration>
  void SetDesiredConfiguration(DesiredConfigurationT&& value) {
    m_desiredConfigurationHasBeenSet = true;
    m_desiredConfiguration = std::forward<DesiredConfigurationT>(value);
  }
  template <typename DesiredConfigurationT = DesiredConfiguration>
  InstanceRefresh& WithDesiredConfiguration(DesiredConfigurationT&& value) {
    SetDesiredConfiguration(std::forward<DesiredConfigurationT>(value));
    return *this;
  }
 
 
  inline const RollbackDetails& GetRollbackDetails() const { return m_rollbackDetails; }
  inline bool RollbackDetailsHasBeenSet() const { return m_rollbackDetailsHasBeenSet; }
  template <typename RollbackDetailsT = RollbackDetails>
  void SetRollbackDetails(RollbackDetailsT&& value) {
    m_rollbackDetailsHasBeenSet = true;
    m_rollbackDetails = std::forward<RollbackDetailsT>(value);
  }
  template <typename RollbackDetailsT = RollbackDetails>
  InstanceRefresh& WithRollbackDetails(RollbackDetailsT&& value) {
    SetRollbackDetails(std::forward<RollbackDetailsT>(value));
    return *this;
  }
 
 
  inline RefreshStrategy GetStrategy() const { return m_strategy; }
  inline bool StrategyHasBeenSet() const { return m_strategyHasBeenSet; }
  inline void SetStrategy(RefreshStrategy value) {
    m_strategyHasBeenSet = true;
    m_strategy = value;
  }
  inline InstanceRefresh& WithStrategy(RefreshStrategy value) {
    SetStrategy(value);
    return *this;
  }
 private:
  Aws::String m_instanceRefreshId;
 
  Aws::String m_autoScalingGroupName;
 
  InstanceRefreshStatus m_status{InstanceRefreshStatus::NOT_SET};
 
  Aws::String m_statusReason;
 
  Aws::Utils::DateTime m_startTime{};
 
  Aws::Utils::DateTime m_endTime{};
 
  int m_percentageComplete{0};
 
  int m_instancesToUpdate{0};
 
  InstanceRefreshProgressDetails m_progressDetails;
 
  RefreshPreferences m_preferences;
 
  DesiredConfiguration m_desiredConfiguration;
 
  RollbackDetails m_rollbackDetails;
 
  RefreshStrategy m_strategy{RefreshStrategy::NOT_SET};
  bool m_instanceRefreshIdHasBeenSet = false;
  bool m_autoScalingGroupNameHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusReasonHasBeenSet = false;
  bool m_startTimeHasBeenSet = false;
  bool m_endTimeHasBeenSet = false;
  bool m_percentageCompleteHasBeenSet = false;
  bool m_instancesToUpdateHasBeenSet = false;
  bool m_progressDetailsHasBeenSet = false;
  bool m_preferencesHasBeenSet = false;
  bool m_desiredConfigurationHasBeenSet = false;
  bool m_rollbackDetailsHasBeenSet = false;
  bool m_strategyHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AutoScaling
}  // namespace Aws