ManagedScaling.h

 
#pragma once
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/ecs/model/ManagedScalingStatus.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace ECS
{
namespace Model
{
 
  class ManagedScaling
  {
  public:
    AWS_ECS_API ManagedScaling();
    AWS_ECS_API ManagedScaling(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API ManagedScaling& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const ManagedScalingStatus& GetStatus() const{ return m_status; }
    inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
    inline void SetStatus(const ManagedScalingStatus& value) { m_statusHasBeenSet = true; m_status = value; }
    inline void SetStatus(ManagedScalingStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
    inline ManagedScaling& WithStatus(const ManagedScalingStatus& value) { SetStatus(value); return *this;}
    inline ManagedScaling& WithStatus(ManagedScalingStatus&& value) { SetStatus(std::move(value)); return *this;}
 
 
    inline int GetTargetCapacity() const{ return m_targetCapacity; }
    inline bool TargetCapacityHasBeenSet() const { return m_targetCapacityHasBeenSet; }
    inline void SetTargetCapacity(int value) { m_targetCapacityHasBeenSet = true; m_targetCapacity = value; }
    inline ManagedScaling& WithTargetCapacity(int value) { SetTargetCapacity(value); return *this;}
 
 
    inline int GetMinimumScalingStepSize() const{ return m_minimumScalingStepSize; }
    inline bool MinimumScalingStepSizeHasBeenSet() const { return m_minimumScalingStepSizeHasBeenSet; }
    inline void SetMinimumScalingStepSize(int value) { m_minimumScalingStepSizeHasBeenSet = true; m_minimumScalingStepSize = value; }
    inline ManagedScaling& WithMinimumScalingStepSize(int value) { SetMinimumScalingStepSize(value); return *this;}
 
 
    inline int GetMaximumScalingStepSize() const{ return m_maximumScalingStepSize; }
    inline bool MaximumScalingStepSizeHasBeenSet() const { return m_maximumScalingStepSizeHasBeenSet; }
    inline void SetMaximumScalingStepSize(int value) { m_maximumScalingStepSizeHasBeenSet = true; m_maximumScalingStepSize = value; }
    inline ManagedScaling& WithMaximumScalingStepSize(int value) { SetMaximumScalingStepSize(value); return *this;}
 
 
    inline int GetInstanceWarmupPeriod() const{ return m_instanceWarmupPeriod; }
    inline bool InstanceWarmupPeriodHasBeenSet() const { return m_instanceWarmupPeriodHasBeenSet; }
    inline void SetInstanceWarmupPeriod(int value) { m_instanceWarmupPeriodHasBeenSet = true; m_instanceWarmupPeriod = value; }
    inline ManagedScaling& WithInstanceWarmupPeriod(int value) { SetInstanceWarmupPeriod(value); return *this;}
  private:
 
    ManagedScalingStatus m_status;
    bool m_statusHasBeenSet = false;
 
    int m_targetCapacity;
    bool m_targetCapacityHasBeenSet = false;
 
    int m_minimumScalingStepSize;
    bool m_minimumScalingStepSizeHasBeenSet = false;
 
    int m_maximumScalingStepSize;
    bool m_maximumScalingStepSizeHasBeenSet = false;
 
    int m_instanceWarmupPeriod;
    bool m_instanceWarmupPeriodHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ECS
} // namespace Aws