InstancesDistribution.h

 
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.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 InstancesDistribution {
 public:
  AWS_AUTOSCALING_API InstancesDistribution() = default;
  AWS_AUTOSCALING_API InstancesDistribution(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_AUTOSCALING_API InstancesDistribution& 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& GetOnDemandAllocationStrategy() const { return m_onDemandAllocationStrategy; }
  inline bool OnDemandAllocationStrategyHasBeenSet() const { return m_onDemandAllocationStrategyHasBeenSet; }
  template <typename OnDemandAllocationStrategyT = Aws::String>
  void SetOnDemandAllocationStrategy(OnDemandAllocationStrategyT&& value) {
    m_onDemandAllocationStrategyHasBeenSet = true;
    m_onDemandAllocationStrategy = std::forward<OnDemandAllocationStrategyT>(value);
  }
  template <typename OnDemandAllocationStrategyT = Aws::String>
  InstancesDistribution& WithOnDemandAllocationStrategy(OnDemandAllocationStrategyT&& value) {
    SetOnDemandAllocationStrategy(std::forward<OnDemandAllocationStrategyT>(value));
    return *this;
  }
 
 
  inline int GetOnDemandBaseCapacity() const { return m_onDemandBaseCapacity; }
  inline bool OnDemandBaseCapacityHasBeenSet() const { return m_onDemandBaseCapacityHasBeenSet; }
  inline void SetOnDemandBaseCapacity(int value) {
    m_onDemandBaseCapacityHasBeenSet = true;
    m_onDemandBaseCapacity = value;
  }
  inline InstancesDistribution& WithOnDemandBaseCapacity(int value) {
    SetOnDemandBaseCapacity(value);
    return *this;
  }
 
 
  inline int GetOnDemandPercentageAboveBaseCapacity() const { return m_onDemandPercentageAboveBaseCapacity; }
  inline bool OnDemandPercentageAboveBaseCapacityHasBeenSet() const { return m_onDemandPercentageAboveBaseCapacityHasBeenSet; }
  inline void SetOnDemandPercentageAboveBaseCapacity(int value) {
    m_onDemandPercentageAboveBaseCapacityHasBeenSet = true;
    m_onDemandPercentageAboveBaseCapacity = value;
  }
  inline InstancesDistribution& WithOnDemandPercentageAboveBaseCapacity(int value) {
    SetOnDemandPercentageAboveBaseCapacity(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSpotAllocationStrategy() const { return m_spotAllocationStrategy; }
  inline bool SpotAllocationStrategyHasBeenSet() const { return m_spotAllocationStrategyHasBeenSet; }
  template <typename SpotAllocationStrategyT = Aws::String>
  void SetSpotAllocationStrategy(SpotAllocationStrategyT&& value) {
    m_spotAllocationStrategyHasBeenSet = true;
    m_spotAllocationStrategy = std::forward<SpotAllocationStrategyT>(value);
  }
  template <typename SpotAllocationStrategyT = Aws::String>
  InstancesDistribution& WithSpotAllocationStrategy(SpotAllocationStrategyT&& value) {
    SetSpotAllocationStrategy(std::forward<SpotAllocationStrategyT>(value));
    return *this;
  }
 
 
  inline int GetSpotInstancePools() const { return m_spotInstancePools; }
  inline bool SpotInstancePoolsHasBeenSet() const { return m_spotInstancePoolsHasBeenSet; }
  inline void SetSpotInstancePools(int value) {
    m_spotInstancePoolsHasBeenSet = true;
    m_spotInstancePools = value;
  }
  inline InstancesDistribution& WithSpotInstancePools(int value) {
    SetSpotInstancePools(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSpotMaxPrice() const { return m_spotMaxPrice; }
  inline bool SpotMaxPriceHasBeenSet() const { return m_spotMaxPriceHasBeenSet; }
  template <typename SpotMaxPriceT = Aws::String>
  void SetSpotMaxPrice(SpotMaxPriceT&& value) {
    m_spotMaxPriceHasBeenSet = true;
    m_spotMaxPrice = std::forward<SpotMaxPriceT>(value);
  }
  template <typename SpotMaxPriceT = Aws::String>
  InstancesDistribution& WithSpotMaxPrice(SpotMaxPriceT&& value) {
    SetSpotMaxPrice(std::forward<SpotMaxPriceT>(value));
    return *this;
  }
 private:
  Aws::String m_onDemandAllocationStrategy;
 
  int m_onDemandBaseCapacity{0};
 
  int m_onDemandPercentageAboveBaseCapacity{0};
 
  Aws::String m_spotAllocationStrategy;
 
  int m_spotInstancePools{0};
 
  Aws::String m_spotMaxPrice;
  bool m_onDemandAllocationStrategyHasBeenSet = false;
  bool m_onDemandBaseCapacityHasBeenSet = false;
  bool m_onDemandPercentageAboveBaseCapacityHasBeenSet = false;
  bool m_spotAllocationStrategyHasBeenSet = false;
  bool m_spotInstancePoolsHasBeenSet = false;
  bool m_spotMaxPriceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AutoScaling
}  // namespace Aws