DeploymentConfiguration.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/ecs/model/CanaryConfiguration.h>
#include <aws/ecs/model/DeploymentAlarms.h>
#include <aws/ecs/model/DeploymentCircuitBreaker.h>
#include <aws/ecs/model/DeploymentEarlySuccessCriteria.h>
#include <aws/ecs/model/DeploymentLifecycleHook.h>
#include <aws/ecs/model/DeploymentStrategy.h>
#include <aws/ecs/model/LinearConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ECS {
namespace Model {
 
class DeploymentConfiguration {
 public:
  AWS_ECS_API DeploymentConfiguration() = default;
  AWS_ECS_API DeploymentConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API DeploymentConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const DeploymentCircuitBreaker& GetDeploymentCircuitBreaker() const { return m_deploymentCircuitBreaker; }
  inline bool DeploymentCircuitBreakerHasBeenSet() const { return m_deploymentCircuitBreakerHasBeenSet; }
  template <typename DeploymentCircuitBreakerT = DeploymentCircuitBreaker>
  void SetDeploymentCircuitBreaker(DeploymentCircuitBreakerT&& value) {
    m_deploymentCircuitBreakerHasBeenSet = true;
    m_deploymentCircuitBreaker = std::forward<DeploymentCircuitBreakerT>(value);
  }
  template <typename DeploymentCircuitBreakerT = DeploymentCircuitBreaker>
  DeploymentConfiguration& WithDeploymentCircuitBreaker(DeploymentCircuitBreakerT&& value) {
    SetDeploymentCircuitBreaker(std::forward<DeploymentCircuitBreakerT>(value));
    return *this;
  }
 
 
  inline int GetMaximumPercent() const { return m_maximumPercent; }
  inline bool MaximumPercentHasBeenSet() const { return m_maximumPercentHasBeenSet; }
  inline void SetMaximumPercent(int value) {
    m_maximumPercentHasBeenSet = true;
    m_maximumPercent = value;
  }
  inline DeploymentConfiguration& WithMaximumPercent(int value) {
    SetMaximumPercent(value);
    return *this;
  }
 
 
  inline int GetMinimumHealthyPercent() const { return m_minimumHealthyPercent; }
  inline bool MinimumHealthyPercentHasBeenSet() const { return m_minimumHealthyPercentHasBeenSet; }
  inline void SetMinimumHealthyPercent(int value) {
    m_minimumHealthyPercentHasBeenSet = true;
    m_minimumHealthyPercent = value;
  }
  inline DeploymentConfiguration& WithMinimumHealthyPercent(int value) {
    SetMinimumHealthyPercent(value);
    return *this;
  }
 
 
  inline const DeploymentAlarms& GetAlarms() const { return m_alarms; }
  inline bool AlarmsHasBeenSet() const { return m_alarmsHasBeenSet; }
  template <typename AlarmsT = DeploymentAlarms>
  void SetAlarms(AlarmsT&& value) {
    m_alarmsHasBeenSet = true;
    m_alarms = std::forward<AlarmsT>(value);
  }
  template <typename AlarmsT = DeploymentAlarms>
  DeploymentConfiguration& WithAlarms(AlarmsT&& value) {
    SetAlarms(std::forward<AlarmsT>(value));
    return *this;
  }
 
 
  inline DeploymentStrategy GetStrategy() const { return m_strategy; }
  inline bool StrategyHasBeenSet() const { return m_strategyHasBeenSet; }
  inline void SetStrategy(DeploymentStrategy value) {
    m_strategyHasBeenSet = true;
    m_strategy = value;
  }
  inline DeploymentConfiguration& WithStrategy(DeploymentStrategy value) {
    SetStrategy(value);
    return *this;
  }
 
 
  inline int GetBakeTimeInMinutes() const { return m_bakeTimeInMinutes; }
  inline bool BakeTimeInMinutesHasBeenSet() const { return m_bakeTimeInMinutesHasBeenSet; }
  inline void SetBakeTimeInMinutes(int value) {
    m_bakeTimeInMinutesHasBeenSet = true;
    m_bakeTimeInMinutes = value;
  }
  inline DeploymentConfiguration& WithBakeTimeInMinutes(int value) {
    SetBakeTimeInMinutes(value);
    return *this;
  }
 
 
  inline const Aws::Vector<DeploymentLifecycleHook>& GetLifecycleHooks() const { return m_lifecycleHooks; }
  inline bool LifecycleHooksHasBeenSet() const { return m_lifecycleHooksHasBeenSet; }
  template <typename LifecycleHooksT = Aws::Vector<DeploymentLifecycleHook>>
  void SetLifecycleHooks(LifecycleHooksT&& value) {
    m_lifecycleHooksHasBeenSet = true;
    m_lifecycleHooks = std::forward<LifecycleHooksT>(value);
  }
  template <typename LifecycleHooksT = Aws::Vector<DeploymentLifecycleHook>>
  DeploymentConfiguration& WithLifecycleHooks(LifecycleHooksT&& value) {
    SetLifecycleHooks(std::forward<LifecycleHooksT>(value));
    return *this;
  }
  template <typename LifecycleHooksT = DeploymentLifecycleHook>
  DeploymentConfiguration& AddLifecycleHooks(LifecycleHooksT&& value) {
    m_lifecycleHooksHasBeenSet = true;
    m_lifecycleHooks.emplace_back(std::forward<LifecycleHooksT>(value));
    return *this;
  }
 
 
  inline const LinearConfiguration& GetLinearConfiguration() const { return m_linearConfiguration; }
  inline bool LinearConfigurationHasBeenSet() const { return m_linearConfigurationHasBeenSet; }
  template <typename LinearConfigurationT = LinearConfiguration>
  void SetLinearConfiguration(LinearConfigurationT&& value) {
    m_linearConfigurationHasBeenSet = true;
    m_linearConfiguration = std::forward<LinearConfigurationT>(value);
  }
  template <typename LinearConfigurationT = LinearConfiguration>
  DeploymentConfiguration& WithLinearConfiguration(LinearConfigurationT&& value) {
    SetLinearConfiguration(std::forward<LinearConfigurationT>(value));
    return *this;
  }
 
 
  inline const CanaryConfiguration& GetCanaryConfiguration() const { return m_canaryConfiguration; }
  inline bool CanaryConfigurationHasBeenSet() const { return m_canaryConfigurationHasBeenSet; }
  template <typename CanaryConfigurationT = CanaryConfiguration>
  void SetCanaryConfiguration(CanaryConfigurationT&& value) {
    m_canaryConfigurationHasBeenSet = true;
    m_canaryConfiguration = std::forward<CanaryConfigurationT>(value);
  }
  template <typename CanaryConfigurationT = CanaryConfiguration>
  DeploymentConfiguration& WithCanaryConfiguration(CanaryConfigurationT&& value) {
    SetCanaryConfiguration(std::forward<CanaryConfigurationT>(value));
    return *this;
  }
 
 
  inline const DeploymentEarlySuccessCriteria& GetEarlySuccessCriteria() const { return m_earlySuccessCriteria; }
  inline bool EarlySuccessCriteriaHasBeenSet() const { return m_earlySuccessCriteriaHasBeenSet; }
  template <typename EarlySuccessCriteriaT = DeploymentEarlySuccessCriteria>
  void SetEarlySuccessCriteria(EarlySuccessCriteriaT&& value) {
    m_earlySuccessCriteriaHasBeenSet = true;
    m_earlySuccessCriteria = std::forward<EarlySuccessCriteriaT>(value);
  }
  template <typename EarlySuccessCriteriaT = DeploymentEarlySuccessCriteria>
  DeploymentConfiguration& WithEarlySuccessCriteria(EarlySuccessCriteriaT&& value) {
    SetEarlySuccessCriteria(std::forward<EarlySuccessCriteriaT>(value));
    return *this;
  }
 private:
  DeploymentCircuitBreaker m_deploymentCircuitBreaker;
 
  int m_maximumPercent{0};
 
  int m_minimumHealthyPercent{0};
 
  DeploymentAlarms m_alarms;
 
  DeploymentStrategy m_strategy{DeploymentStrategy::NOT_SET};
 
  int m_bakeTimeInMinutes{0};
 
  Aws::Vector<DeploymentLifecycleHook> m_lifecycleHooks;
 
  LinearConfiguration m_linearConfiguration;
 
  CanaryConfiguration m_canaryConfiguration;
 
  DeploymentEarlySuccessCriteria m_earlySuccessCriteria;
  bool m_deploymentCircuitBreakerHasBeenSet = false;
  bool m_maximumPercentHasBeenSet = false;
  bool m_minimumHealthyPercentHasBeenSet = false;
  bool m_alarmsHasBeenSet = false;
  bool m_strategyHasBeenSet = false;
  bool m_bakeTimeInMinutesHasBeenSet = false;
  bool m_lifecycleHooksHasBeenSet = false;
  bool m_linearConfigurationHasBeenSet = false;
  bool m_canaryConfigurationHasBeenSet = false;
  bool m_earlySuccessCriteriaHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws