InstanceRequirements.h

 
#pragma once
#include <aws/autoscaling/AutoScaling_EXPORTS.h>
#include <aws/autoscaling/model/AcceleratorCountRequest.h>
#include <aws/autoscaling/model/AcceleratorManufacturer.h>
#include <aws/autoscaling/model/AcceleratorName.h>
#include <aws/autoscaling/model/AcceleratorTotalMemoryMiBRequest.h>
#include <aws/autoscaling/model/AcceleratorType.h>
#include <aws/autoscaling/model/BareMetal.h>
#include <aws/autoscaling/model/BaselineEbsBandwidthMbpsRequest.h>
#include <aws/autoscaling/model/BaselinePerformanceFactorsRequest.h>
#include <aws/autoscaling/model/BurstablePerformance.h>
#include <aws/autoscaling/model/CpuManufacturer.h>
#include <aws/autoscaling/model/InstanceGeneration.h>
#include <aws/autoscaling/model/LocalStorage.h>
#include <aws/autoscaling/model/LocalStorageType.h>
#include <aws/autoscaling/model/MemoryGiBPerVCpuRequest.h>
#include <aws/autoscaling/model/MemoryMiBRequest.h>
#include <aws/autoscaling/model/NetworkBandwidthGbpsRequest.h>
#include <aws/autoscaling/model/NetworkInterfaceCountRequest.h>
#include <aws/autoscaling/model/TotalLocalStorageGBRequest.h>
#include <aws/autoscaling/model/VCpuCountRequest.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace AutoScaling {
namespace Model {
 
class InstanceRequirements {
 public:
  AWS_AUTOSCALING_API InstanceRequirements() = default;
  AWS_AUTOSCALING_API InstanceRequirements(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_AUTOSCALING_API InstanceRequirements& 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 VCpuCountRequest& GetVCpuCount() const { return m_vCpuCount; }
  inline bool VCpuCountHasBeenSet() const { return m_vCpuCountHasBeenSet; }
  template <typename VCpuCountT = VCpuCountRequest>
  void SetVCpuCount(VCpuCountT&& value) {
    m_vCpuCountHasBeenSet = true;
    m_vCpuCount = std::forward<VCpuCountT>(value);
  }
  template <typename VCpuCountT = VCpuCountRequest>
  InstanceRequirements& WithVCpuCount(VCpuCountT&& value) {
    SetVCpuCount(std::forward<VCpuCountT>(value));
    return *this;
  }
 
 
  inline const MemoryMiBRequest& GetMemoryMiB() const { return m_memoryMiB; }
  inline bool MemoryMiBHasBeenSet() const { return m_memoryMiBHasBeenSet; }
  template <typename MemoryMiBT = MemoryMiBRequest>
  void SetMemoryMiB(MemoryMiBT&& value) {
    m_memoryMiBHasBeenSet = true;
    m_memoryMiB = std::forward<MemoryMiBT>(value);
  }
  template <typename MemoryMiBT = MemoryMiBRequest>
  InstanceRequirements& WithMemoryMiB(MemoryMiBT&& value) {
    SetMemoryMiB(std::forward<MemoryMiBT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CpuManufacturer>& GetCpuManufacturers() const { return m_cpuManufacturers; }
  inline bool CpuManufacturersHasBeenSet() const { return m_cpuManufacturersHasBeenSet; }
  template <typename CpuManufacturersT = Aws::Vector<CpuManufacturer>>
  void SetCpuManufacturers(CpuManufacturersT&& value) {
    m_cpuManufacturersHasBeenSet = true;
    m_cpuManufacturers = std::forward<CpuManufacturersT>(value);
  }
  template <typename CpuManufacturersT = Aws::Vector<CpuManufacturer>>
  InstanceRequirements& WithCpuManufacturers(CpuManufacturersT&& value) {
    SetCpuManufacturers(std::forward<CpuManufacturersT>(value));
    return *this;
  }
  inline InstanceRequirements& AddCpuManufacturers(CpuManufacturer value) {
    m_cpuManufacturersHasBeenSet = true;
    m_cpuManufacturers.push_back(value);
    return *this;
  }
 
 
  inline const MemoryGiBPerVCpuRequest& GetMemoryGiBPerVCpu() const { return m_memoryGiBPerVCpu; }
  inline bool MemoryGiBPerVCpuHasBeenSet() const { return m_memoryGiBPerVCpuHasBeenSet; }
  template <typename MemoryGiBPerVCpuT = MemoryGiBPerVCpuRequest>
  void SetMemoryGiBPerVCpu(MemoryGiBPerVCpuT&& value) {
    m_memoryGiBPerVCpuHasBeenSet = true;
    m_memoryGiBPerVCpu = std::forward<MemoryGiBPerVCpuT>(value);
  }
  template <typename MemoryGiBPerVCpuT = MemoryGiBPerVCpuRequest>
  InstanceRequirements& WithMemoryGiBPerVCpu(MemoryGiBPerVCpuT&& value) {
    SetMemoryGiBPerVCpu(std::forward<MemoryGiBPerVCpuT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetExcludedInstanceTypes() const { return m_excludedInstanceTypes; }
  inline bool ExcludedInstanceTypesHasBeenSet() const { return m_excludedInstanceTypesHasBeenSet; }
  template <typename ExcludedInstanceTypesT = Aws::Vector<Aws::String>>
  void SetExcludedInstanceTypes(ExcludedInstanceTypesT&& value) {
    m_excludedInstanceTypesHasBeenSet = true;
    m_excludedInstanceTypes = std::forward<ExcludedInstanceTypesT>(value);
  }
  template <typename ExcludedInstanceTypesT = Aws::Vector<Aws::String>>
  InstanceRequirements& WithExcludedInstanceTypes(ExcludedInstanceTypesT&& value) {
    SetExcludedInstanceTypes(std::forward<ExcludedInstanceTypesT>(value));
    return *this;
  }
  template <typename ExcludedInstanceTypesT = Aws::String>
  InstanceRequirements& AddExcludedInstanceTypes(ExcludedInstanceTypesT&& value) {
    m_excludedInstanceTypesHasBeenSet = true;
    m_excludedInstanceTypes.emplace_back(std::forward<ExcludedInstanceTypesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<InstanceGeneration>& GetInstanceGenerations() const { return m_instanceGenerations; }
  inline bool InstanceGenerationsHasBeenSet() const { return m_instanceGenerationsHasBeenSet; }
  template <typename InstanceGenerationsT = Aws::Vector<InstanceGeneration>>
  void SetInstanceGenerations(InstanceGenerationsT&& value) {
    m_instanceGenerationsHasBeenSet = true;
    m_instanceGenerations = std::forward<InstanceGenerationsT>(value);
  }
  template <typename InstanceGenerationsT = Aws::Vector<InstanceGeneration>>
  InstanceRequirements& WithInstanceGenerations(InstanceGenerationsT&& value) {
    SetInstanceGenerations(std::forward<InstanceGenerationsT>(value));
    return *this;
  }
  inline InstanceRequirements& AddInstanceGenerations(InstanceGeneration value) {
    m_instanceGenerationsHasBeenSet = true;
    m_instanceGenerations.push_back(value);
    return *this;
  }
 
 
  inline int GetSpotMaxPricePercentageOverLowestPrice() const { return m_spotMaxPricePercentageOverLowestPrice; }
  inline bool SpotMaxPricePercentageOverLowestPriceHasBeenSet() const { return m_spotMaxPricePercentageOverLowestPriceHasBeenSet; }
  inline void SetSpotMaxPricePercentageOverLowestPrice(int value) {
    m_spotMaxPricePercentageOverLowestPriceHasBeenSet = true;
    m_spotMaxPricePercentageOverLowestPrice = value;
  }
  inline InstanceRequirements& WithSpotMaxPricePercentageOverLowestPrice(int value) {
    SetSpotMaxPricePercentageOverLowestPrice(value);
    return *this;
  }
 
 
  inline int GetMaxSpotPriceAsPercentageOfOptimalOnDemandPrice() const { return m_maxSpotPriceAsPercentageOfOptimalOnDemandPrice; }
  inline bool MaxSpotPriceAsPercentageOfOptimalOnDemandPriceHasBeenSet() const {
    return m_maxSpotPriceAsPercentageOfOptimalOnDemandPriceHasBeenSet;
  }
  inline void SetMaxSpotPriceAsPercentageOfOptimalOnDemandPrice(int value) {
    m_maxSpotPriceAsPercentageOfOptimalOnDemandPriceHasBeenSet = true;
    m_maxSpotPriceAsPercentageOfOptimalOnDemandPrice = value;
  }
  inline InstanceRequirements& WithMaxSpotPriceAsPercentageOfOptimalOnDemandPrice(int value) {
    SetMaxSpotPriceAsPercentageOfOptimalOnDemandPrice(value);
    return *this;
  }
 
 
  inline int GetOnDemandMaxPricePercentageOverLowestPrice() const { return m_onDemandMaxPricePercentageOverLowestPrice; }
  inline bool OnDemandMaxPricePercentageOverLowestPriceHasBeenSet() const { return m_onDemandMaxPricePercentageOverLowestPriceHasBeenSet; }
  inline void SetOnDemandMaxPricePercentageOverLowestPrice(int value) {
    m_onDemandMaxPricePercentageOverLowestPriceHasBeenSet = true;
    m_onDemandMaxPricePercentageOverLowestPrice = value;
  }
  inline InstanceRequirements& WithOnDemandMaxPricePercentageOverLowestPrice(int value) {
    SetOnDemandMaxPricePercentageOverLowestPrice(value);
    return *this;
  }
 
 
  inline BareMetal GetBareMetal() const { return m_bareMetal; }
  inline bool BareMetalHasBeenSet() const { return m_bareMetalHasBeenSet; }
  inline void SetBareMetal(BareMetal value) {
    m_bareMetalHasBeenSet = true;
    m_bareMetal = value;
  }
  inline InstanceRequirements& WithBareMetal(BareMetal value) {
    SetBareMetal(value);
    return *this;
  }
 
 
  inline BurstablePerformance GetBurstablePerformance() const { return m_burstablePerformance; }
  inline bool BurstablePerformanceHasBeenSet() const { return m_burstablePerformanceHasBeenSet; }
  inline void SetBurstablePerformance(BurstablePerformance value) {
    m_burstablePerformanceHasBeenSet = true;
    m_burstablePerformance = value;
  }
  inline InstanceRequirements& WithBurstablePerformance(BurstablePerformance value) {
    SetBurstablePerformance(value);
    return *this;
  }
 
 
  inline bool GetRequireHibernateSupport() const { return m_requireHibernateSupport; }
  inline bool RequireHibernateSupportHasBeenSet() const { return m_requireHibernateSupportHasBeenSet; }
  inline void SetRequireHibernateSupport(bool value) {
    m_requireHibernateSupportHasBeenSet = true;
    m_requireHibernateSupport = value;
  }
  inline InstanceRequirements& WithRequireHibernateSupport(bool value) {
    SetRequireHibernateSupport(value);
    return *this;
  }
 
 
  inline const NetworkInterfaceCountRequest& GetNetworkInterfaceCount() const { return m_networkInterfaceCount; }
  inline bool NetworkInterfaceCountHasBeenSet() const { return m_networkInterfaceCountHasBeenSet; }
  template <typename NetworkInterfaceCountT = NetworkInterfaceCountRequest>
  void SetNetworkInterfaceCount(NetworkInterfaceCountT&& value) {
    m_networkInterfaceCountHasBeenSet = true;
    m_networkInterfaceCount = std::forward<NetworkInterfaceCountT>(value);
  }
  template <typename NetworkInterfaceCountT = NetworkInterfaceCountRequest>
  InstanceRequirements& WithNetworkInterfaceCount(NetworkInterfaceCountT&& value) {
    SetNetworkInterfaceCount(std::forward<NetworkInterfaceCountT>(value));
    return *this;
  }
 
 
  inline LocalStorage GetLocalStorage() const { return m_localStorage; }
  inline bool LocalStorageHasBeenSet() const { return m_localStorageHasBeenSet; }
  inline void SetLocalStorage(LocalStorage value) {
    m_localStorageHasBeenSet = true;
    m_localStorage = value;
  }
  inline InstanceRequirements& WithLocalStorage(LocalStorage value) {
    SetLocalStorage(value);
    return *this;
  }
 
 
  inline const Aws::Vector<LocalStorageType>& GetLocalStorageTypes() const { return m_localStorageTypes; }
  inline bool LocalStorageTypesHasBeenSet() const { return m_localStorageTypesHasBeenSet; }
  template <typename LocalStorageTypesT = Aws::Vector<LocalStorageType>>
  void SetLocalStorageTypes(LocalStorageTypesT&& value) {
    m_localStorageTypesHasBeenSet = true;
    m_localStorageTypes = std::forward<LocalStorageTypesT>(value);
  }
  template <typename LocalStorageTypesT = Aws::Vector<LocalStorageType>>
  InstanceRequirements& WithLocalStorageTypes(LocalStorageTypesT&& value) {
    SetLocalStorageTypes(std::forward<LocalStorageTypesT>(value));
    return *this;
  }
  inline InstanceRequirements& AddLocalStorageTypes(LocalStorageType value) {
    m_localStorageTypesHasBeenSet = true;
    m_localStorageTypes.push_back(value);
    return *this;
  }
 
 
  inline const TotalLocalStorageGBRequest& GetTotalLocalStorageGB() const { return m_totalLocalStorageGB; }
  inline bool TotalLocalStorageGBHasBeenSet() const { return m_totalLocalStorageGBHasBeenSet; }
  template <typename TotalLocalStorageGBT = TotalLocalStorageGBRequest>
  void SetTotalLocalStorageGB(TotalLocalStorageGBT&& value) {
    m_totalLocalStorageGBHasBeenSet = true;
    m_totalLocalStorageGB = std::forward<TotalLocalStorageGBT>(value);
  }
  template <typename TotalLocalStorageGBT = TotalLocalStorageGBRequest>
  InstanceRequirements& WithTotalLocalStorageGB(TotalLocalStorageGBT&& value) {
    SetTotalLocalStorageGB(std::forward<TotalLocalStorageGBT>(value));
    return *this;
  }
 
 
  inline const BaselineEbsBandwidthMbpsRequest& GetBaselineEbsBandwidthMbps() const { return m_baselineEbsBandwidthMbps; }
  inline bool BaselineEbsBandwidthMbpsHasBeenSet() const { return m_baselineEbsBandwidthMbpsHasBeenSet; }
  template <typename BaselineEbsBandwidthMbpsT = BaselineEbsBandwidthMbpsRequest>
  void SetBaselineEbsBandwidthMbps(BaselineEbsBandwidthMbpsT&& value) {
    m_baselineEbsBandwidthMbpsHasBeenSet = true;
    m_baselineEbsBandwidthMbps = std::forward<BaselineEbsBandwidthMbpsT>(value);
  }
  template <typename BaselineEbsBandwidthMbpsT = BaselineEbsBandwidthMbpsRequest>
  InstanceRequirements& WithBaselineEbsBandwidthMbps(BaselineEbsBandwidthMbpsT&& value) {
    SetBaselineEbsBandwidthMbps(std::forward<BaselineEbsBandwidthMbpsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AcceleratorType>& GetAcceleratorTypes() const { return m_acceleratorTypes; }
  inline bool AcceleratorTypesHasBeenSet() const { return m_acceleratorTypesHasBeenSet; }
  template <typename AcceleratorTypesT = Aws::Vector<AcceleratorType>>
  void SetAcceleratorTypes(AcceleratorTypesT&& value) {
    m_acceleratorTypesHasBeenSet = true;
    m_acceleratorTypes = std::forward<AcceleratorTypesT>(value);
  }
  template <typename AcceleratorTypesT = Aws::Vector<AcceleratorType>>
  InstanceRequirements& WithAcceleratorTypes(AcceleratorTypesT&& value) {
    SetAcceleratorTypes(std::forward<AcceleratorTypesT>(value));
    return *this;
  }
  inline InstanceRequirements& AddAcceleratorTypes(AcceleratorType value) {
    m_acceleratorTypesHasBeenSet = true;
    m_acceleratorTypes.push_back(value);
    return *this;
  }
 
 
  inline const AcceleratorCountRequest& GetAcceleratorCount() const { return m_acceleratorCount; }
  inline bool AcceleratorCountHasBeenSet() const { return m_acceleratorCountHasBeenSet; }
  template <typename AcceleratorCountT = AcceleratorCountRequest>
  void SetAcceleratorCount(AcceleratorCountT&& value) {
    m_acceleratorCountHasBeenSet = true;
    m_acceleratorCount = std::forward<AcceleratorCountT>(value);
  }
  template <typename AcceleratorCountT = AcceleratorCountRequest>
  InstanceRequirements& WithAcceleratorCount(AcceleratorCountT&& value) {
    SetAcceleratorCount(std::forward<AcceleratorCountT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AcceleratorManufacturer>& GetAcceleratorManufacturers() const { return m_acceleratorManufacturers; }
  inline bool AcceleratorManufacturersHasBeenSet() const { return m_acceleratorManufacturersHasBeenSet; }
  template <typename AcceleratorManufacturersT = Aws::Vector<AcceleratorManufacturer>>
  void SetAcceleratorManufacturers(AcceleratorManufacturersT&& value) {
    m_acceleratorManufacturersHasBeenSet = true;
    m_acceleratorManufacturers = std::forward<AcceleratorManufacturersT>(value);
  }
  template <typename AcceleratorManufacturersT = Aws::Vector<AcceleratorManufacturer>>
  InstanceRequirements& WithAcceleratorManufacturers(AcceleratorManufacturersT&& value) {
    SetAcceleratorManufacturers(std::forward<AcceleratorManufacturersT>(value));
    return *this;
  }
  inline InstanceRequirements& AddAcceleratorManufacturers(AcceleratorManufacturer value) {
    m_acceleratorManufacturersHasBeenSet = true;
    m_acceleratorManufacturers.push_back(value);
    return *this;
  }
 
 
  inline const Aws::Vector<AcceleratorName>& GetAcceleratorNames() const { return m_acceleratorNames; }
  inline bool AcceleratorNamesHasBeenSet() const { return m_acceleratorNamesHasBeenSet; }
  template <typename AcceleratorNamesT = Aws::Vector<AcceleratorName>>
  void SetAcceleratorNames(AcceleratorNamesT&& value) {
    m_acceleratorNamesHasBeenSet = true;
    m_acceleratorNames = std::forward<AcceleratorNamesT>(value);
  }
  template <typename AcceleratorNamesT = Aws::Vector<AcceleratorName>>
  InstanceRequirements& WithAcceleratorNames(AcceleratorNamesT&& value) {
    SetAcceleratorNames(std::forward<AcceleratorNamesT>(value));
    return *this;
  }
  inline InstanceRequirements& AddAcceleratorNames(AcceleratorName value) {
    m_acceleratorNamesHasBeenSet = true;
    m_acceleratorNames.push_back(value);
    return *this;
  }
 
 
  inline const AcceleratorTotalMemoryMiBRequest& GetAcceleratorTotalMemoryMiB() const { return m_acceleratorTotalMemoryMiB; }
  inline bool AcceleratorTotalMemoryMiBHasBeenSet() const { return m_acceleratorTotalMemoryMiBHasBeenSet; }
  template <typename AcceleratorTotalMemoryMiBT = AcceleratorTotalMemoryMiBRequest>
  void SetAcceleratorTotalMemoryMiB(AcceleratorTotalMemoryMiBT&& value) {
    m_acceleratorTotalMemoryMiBHasBeenSet = true;
    m_acceleratorTotalMemoryMiB = std::forward<AcceleratorTotalMemoryMiBT>(value);
  }
  template <typename AcceleratorTotalMemoryMiBT = AcceleratorTotalMemoryMiBRequest>
  InstanceRequirements& WithAcceleratorTotalMemoryMiB(AcceleratorTotalMemoryMiBT&& value) {
    SetAcceleratorTotalMemoryMiB(std::forward<AcceleratorTotalMemoryMiBT>(value));
    return *this;
  }
 
 
  inline const NetworkBandwidthGbpsRequest& GetNetworkBandwidthGbps() const { return m_networkBandwidthGbps; }
  inline bool NetworkBandwidthGbpsHasBeenSet() const { return m_networkBandwidthGbpsHasBeenSet; }
  template <typename NetworkBandwidthGbpsT = NetworkBandwidthGbpsRequest>
  void SetNetworkBandwidthGbps(NetworkBandwidthGbpsT&& value) {
    m_networkBandwidthGbpsHasBeenSet = true;
    m_networkBandwidthGbps = std::forward<NetworkBandwidthGbpsT>(value);
  }
  template <typename NetworkBandwidthGbpsT = NetworkBandwidthGbpsRequest>
  InstanceRequirements& WithNetworkBandwidthGbps(NetworkBandwidthGbpsT&& value) {
    SetNetworkBandwidthGbps(std::forward<NetworkBandwidthGbpsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetAllowedInstanceTypes() const { return m_allowedInstanceTypes; }
  inline bool AllowedInstanceTypesHasBeenSet() const { return m_allowedInstanceTypesHasBeenSet; }
  template <typename AllowedInstanceTypesT = Aws::Vector<Aws::String>>
  void SetAllowedInstanceTypes(AllowedInstanceTypesT&& value) {
    m_allowedInstanceTypesHasBeenSet = true;
    m_allowedInstanceTypes = std::forward<AllowedInstanceTypesT>(value);
  }
  template <typename AllowedInstanceTypesT = Aws::Vector<Aws::String>>
  InstanceRequirements& WithAllowedInstanceTypes(AllowedInstanceTypesT&& value) {
    SetAllowedInstanceTypes(std::forward<AllowedInstanceTypesT>(value));
    return *this;
  }
  template <typename AllowedInstanceTypesT = Aws::String>
  InstanceRequirements& AddAllowedInstanceTypes(AllowedInstanceTypesT&& value) {
    m_allowedInstanceTypesHasBeenSet = true;
    m_allowedInstanceTypes.emplace_back(std::forward<AllowedInstanceTypesT>(value));
    return *this;
  }
 
 
  inline const BaselinePerformanceFactorsRequest& GetBaselinePerformanceFactors() const { return m_baselinePerformanceFactors; }
  inline bool BaselinePerformanceFactorsHasBeenSet() const { return m_baselinePerformanceFactorsHasBeenSet; }
  template <typename BaselinePerformanceFactorsT = BaselinePerformanceFactorsRequest>
  void SetBaselinePerformanceFactors(BaselinePerformanceFactorsT&& value) {
    m_baselinePerformanceFactorsHasBeenSet = true;
    m_baselinePerformanceFactors = std::forward<BaselinePerformanceFactorsT>(value);
  }
  template <typename BaselinePerformanceFactorsT = BaselinePerformanceFactorsRequest>
  InstanceRequirements& WithBaselinePerformanceFactors(BaselinePerformanceFactorsT&& value) {
    SetBaselinePerformanceFactors(std::forward<BaselinePerformanceFactorsT>(value));
    return *this;
  }
 private:
  VCpuCountRequest m_vCpuCount;
 
  MemoryMiBRequest m_memoryMiB;
 
  Aws::Vector<CpuManufacturer> m_cpuManufacturers;
 
  MemoryGiBPerVCpuRequest m_memoryGiBPerVCpu;
 
  Aws::Vector<Aws::String> m_excludedInstanceTypes;
 
  Aws::Vector<InstanceGeneration> m_instanceGenerations;
 
  int m_spotMaxPricePercentageOverLowestPrice{0};
 
  int m_maxSpotPriceAsPercentageOfOptimalOnDemandPrice{0};
 
  int m_onDemandMaxPricePercentageOverLowestPrice{0};
 
  BareMetal m_bareMetal{BareMetal::NOT_SET};
 
  BurstablePerformance m_burstablePerformance{BurstablePerformance::NOT_SET};
 
  bool m_requireHibernateSupport{false};
 
  NetworkInterfaceCountRequest m_networkInterfaceCount;
 
  LocalStorage m_localStorage{LocalStorage::NOT_SET};
 
  Aws::Vector<LocalStorageType> m_localStorageTypes;
 
  TotalLocalStorageGBRequest m_totalLocalStorageGB;
 
  BaselineEbsBandwidthMbpsRequest m_baselineEbsBandwidthMbps;
 
  Aws::Vector<AcceleratorType> m_acceleratorTypes;
 
  AcceleratorCountRequest m_acceleratorCount;
 
  Aws::Vector<AcceleratorManufacturer> m_acceleratorManufacturers;
 
  Aws::Vector<AcceleratorName> m_acceleratorNames;
 
  AcceleratorTotalMemoryMiBRequest m_acceleratorTotalMemoryMiB;
 
  NetworkBandwidthGbpsRequest m_networkBandwidthGbps;
 
  Aws::Vector<Aws::String> m_allowedInstanceTypes;
 
  BaselinePerformanceFactorsRequest m_baselinePerformanceFactors;
  bool m_vCpuCountHasBeenSet = false;
  bool m_memoryMiBHasBeenSet = false;
  bool m_cpuManufacturersHasBeenSet = false;
  bool m_memoryGiBPerVCpuHasBeenSet = false;
  bool m_excludedInstanceTypesHasBeenSet = false;
  bool m_instanceGenerationsHasBeenSet = false;
  bool m_spotMaxPricePercentageOverLowestPriceHasBeenSet = false;
  bool m_maxSpotPriceAsPercentageOfOptimalOnDemandPriceHasBeenSet = false;
  bool m_onDemandMaxPricePercentageOverLowestPriceHasBeenSet = false;
  bool m_bareMetalHasBeenSet = false;
  bool m_burstablePerformanceHasBeenSet = false;
  bool m_requireHibernateSupportHasBeenSet = false;
  bool m_networkInterfaceCountHasBeenSet = false;
  bool m_localStorageHasBeenSet = false;
  bool m_localStorageTypesHasBeenSet = false;
  bool m_totalLocalStorageGBHasBeenSet = false;
  bool m_baselineEbsBandwidthMbpsHasBeenSet = false;
  bool m_acceleratorTypesHasBeenSet = false;
  bool m_acceleratorCountHasBeenSet = false;
  bool m_acceleratorManufacturersHasBeenSet = false;
  bool m_acceleratorNamesHasBeenSet = false;
  bool m_acceleratorTotalMemoryMiBHasBeenSet = false;
  bool m_networkBandwidthGbpsHasBeenSet = false;
  bool m_allowedInstanceTypesHasBeenSet = false;
  bool m_baselinePerformanceFactorsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace AutoScaling
}  // namespace Aws