LicenseConfiguration.h

 
#pragma once
#include <aws/compute-optimizer/ComputeOptimizer_EXPORTS.h>
#include <aws/compute-optimizer/model/LicenseEdition.h>
#include <aws/compute-optimizer/model/LicenseModel.h>
#include <aws/compute-optimizer/model/LicenseName.h>
#include <aws/compute-optimizer/model/MetricSource.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ComputeOptimizer {
namespace Model {
 
class LicenseConfiguration {
 public:
  AWS_COMPUTEOPTIMIZER_API LicenseConfiguration() = default;
  AWS_COMPUTEOPTIMIZER_API LicenseConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_COMPUTEOPTIMIZER_API LicenseConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_COMPUTEOPTIMIZER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline int GetNumberOfCores() const { return m_numberOfCores; }
  inline bool NumberOfCoresHasBeenSet() const { return m_numberOfCoresHasBeenSet; }
  inline void SetNumberOfCores(int value) {
    m_numberOfCoresHasBeenSet = true;
    m_numberOfCores = value;
  }
  inline LicenseConfiguration& WithNumberOfCores(int value) {
    SetNumberOfCores(value);
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceType() const { return m_instanceType; }
  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
  template <typename InstanceTypeT = Aws::String>
  void SetInstanceType(InstanceTypeT&& value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = std::forward<InstanceTypeT>(value);
  }
  template <typename InstanceTypeT = Aws::String>
  LicenseConfiguration& WithInstanceType(InstanceTypeT&& value) {
    SetInstanceType(std::forward<InstanceTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOperatingSystem() const { return m_operatingSystem; }
  inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
  template <typename OperatingSystemT = Aws::String>
  void SetOperatingSystem(OperatingSystemT&& value) {
    m_operatingSystemHasBeenSet = true;
    m_operatingSystem = std::forward<OperatingSystemT>(value);
  }
  template <typename OperatingSystemT = Aws::String>
  LicenseConfiguration& WithOperatingSystem(OperatingSystemT&& value) {
    SetOperatingSystem(std::forward<OperatingSystemT>(value));
    return *this;
  }
 
 
  inline LicenseEdition GetLicenseEdition() const { return m_licenseEdition; }
  inline bool LicenseEditionHasBeenSet() const { return m_licenseEditionHasBeenSet; }
  inline void SetLicenseEdition(LicenseEdition value) {
    m_licenseEditionHasBeenSet = true;
    m_licenseEdition = value;
  }
  inline LicenseConfiguration& WithLicenseEdition(LicenseEdition value) {
    SetLicenseEdition(value);
    return *this;
  }
 
 
  inline LicenseName GetLicenseName() const { return m_licenseName; }
  inline bool LicenseNameHasBeenSet() const { return m_licenseNameHasBeenSet; }
  inline void SetLicenseName(LicenseName value) {
    m_licenseNameHasBeenSet = true;
    m_licenseName = value;
  }
  inline LicenseConfiguration& WithLicenseName(LicenseName value) {
    SetLicenseName(value);
    return *this;
  }
 
 
  inline LicenseModel GetLicenseModel() const { return m_licenseModel; }
  inline bool LicenseModelHasBeenSet() const { return m_licenseModelHasBeenSet; }
  inline void SetLicenseModel(LicenseModel value) {
    m_licenseModelHasBeenSet = true;
    m_licenseModel = value;
  }
  inline LicenseConfiguration& WithLicenseModel(LicenseModel value) {
    SetLicenseModel(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLicenseVersion() const { return m_licenseVersion; }
  inline bool LicenseVersionHasBeenSet() const { return m_licenseVersionHasBeenSet; }
  template <typename LicenseVersionT = Aws::String>
  void SetLicenseVersion(LicenseVersionT&& value) {
    m_licenseVersionHasBeenSet = true;
    m_licenseVersion = std::forward<LicenseVersionT>(value);
  }
  template <typename LicenseVersionT = Aws::String>
  LicenseConfiguration& WithLicenseVersion(LicenseVersionT&& value) {
    SetLicenseVersion(std::forward<LicenseVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<MetricSource>& GetMetricsSource() const { return m_metricsSource; }
  inline bool MetricsSourceHasBeenSet() const { return m_metricsSourceHasBeenSet; }
  template <typename MetricsSourceT = Aws::Vector<MetricSource>>
  void SetMetricsSource(MetricsSourceT&& value) {
    m_metricsSourceHasBeenSet = true;
    m_metricsSource = std::forward<MetricsSourceT>(value);
  }
  template <typename MetricsSourceT = Aws::Vector<MetricSource>>
  LicenseConfiguration& WithMetricsSource(MetricsSourceT&& value) {
    SetMetricsSource(std::forward<MetricsSourceT>(value));
    return *this;
  }
  template <typename MetricsSourceT = MetricSource>
  LicenseConfiguration& AddMetricsSource(MetricsSourceT&& value) {
    m_metricsSourceHasBeenSet = true;
    m_metricsSource.emplace_back(std::forward<MetricsSourceT>(value));
    return *this;
  }
 private:
  int m_numberOfCores{0};
 
  Aws::String m_instanceType;
 
  Aws::String m_operatingSystem;
 
  LicenseEdition m_licenseEdition{LicenseEdition::NOT_SET};
 
  LicenseName m_licenseName{LicenseName::NOT_SET};
 
  LicenseModel m_licenseModel{LicenseModel::NOT_SET};
 
  Aws::String m_licenseVersion;
 
  Aws::Vector<MetricSource> m_metricsSource;
  bool m_numberOfCoresHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_operatingSystemHasBeenSet = false;
  bool m_licenseEditionHasBeenSet = false;
  bool m_licenseNameHasBeenSet = false;
  bool m_licenseModelHasBeenSet = false;
  bool m_licenseVersionHasBeenSet = false;
  bool m_metricsSourceHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ComputeOptimizer
}  // namespace Aws