DeploymentConfiguration.h

 
#pragma once
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/ecs/model/DeploymentCircuitBreaker.h>
#include <aws/ecs/model/DeploymentAlarms.h>
#include <aws/ecs/model/DeploymentStrategy.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/model/DeploymentLifecycleHook.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; }
  private:
 
    DeploymentCircuitBreaker m_deploymentCircuitBreaker;
    bool m_deploymentCircuitBreakerHasBeenSet = false;
 
    int m_maximumPercent{0};
    bool m_maximumPercentHasBeenSet = false;
 
    int m_minimumHealthyPercent{0};
    bool m_minimumHealthyPercentHasBeenSet = false;
 
    DeploymentAlarms m_alarms;
    bool m_alarmsHasBeenSet = false;
 
    DeploymentStrategy m_strategy{DeploymentStrategy::NOT_SET};
    bool m_strategyHasBeenSet = false;
 
    int m_bakeTimeInMinutes{0};
    bool m_bakeTimeInMinutesHasBeenSet = false;
 
    Aws::Vector<DeploymentLifecycleHook> m_lifecycleHooks;
    bool m_lifecycleHooksHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ECS
} // namespace Aws