InstanceRecommendationOption.h

 
#pragma once
#include <aws/compute-optimizer/ComputeOptimizer_EXPORTS.h>
#include <aws/compute-optimizer/model/GpuInfo.h>
#include <aws/compute-optimizer/model/InstanceSavingsOpportunityAfterDiscounts.h>
#include <aws/compute-optimizer/model/MigrationEffort.h>
#include <aws/compute-optimizer/model/PlatformDifference.h>
#include <aws/compute-optimizer/model/SavingsOpportunity.h>
#include <aws/compute-optimizer/model/UtilizationMetric.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 InstanceRecommendationOption {
 public:
  AWS_COMPUTEOPTIMIZER_API InstanceRecommendationOption() = default;
  AWS_COMPUTEOPTIMIZER_API InstanceRecommendationOption(Aws::Utils::Json::JsonView jsonValue);
  AWS_COMPUTEOPTIMIZER_API InstanceRecommendationOption& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_COMPUTEOPTIMIZER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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>
  InstanceRecommendationOption& WithInstanceType(InstanceTypeT&& value) {
    SetInstanceType(std::forward<InstanceTypeT>(value));
    return *this;
  }
 
 
  inline const GpuInfo& GetInstanceGpuInfo() const { return m_instanceGpuInfo; }
  inline bool InstanceGpuInfoHasBeenSet() const { return m_instanceGpuInfoHasBeenSet; }
  template <typename InstanceGpuInfoT = GpuInfo>
  void SetInstanceGpuInfo(InstanceGpuInfoT&& value) {
    m_instanceGpuInfoHasBeenSet = true;
    m_instanceGpuInfo = std::forward<InstanceGpuInfoT>(value);
  }
  template <typename InstanceGpuInfoT = GpuInfo>
  InstanceRecommendationOption& WithInstanceGpuInfo(InstanceGpuInfoT&& value) {
    SetInstanceGpuInfo(std::forward<InstanceGpuInfoT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<UtilizationMetric>& GetProjectedUtilizationMetrics() const { return m_projectedUtilizationMetrics; }
  inline bool ProjectedUtilizationMetricsHasBeenSet() const { return m_projectedUtilizationMetricsHasBeenSet; }
  template <typename ProjectedUtilizationMetricsT = Aws::Vector<UtilizationMetric>>
  void SetProjectedUtilizationMetrics(ProjectedUtilizationMetricsT&& value) {
    m_projectedUtilizationMetricsHasBeenSet = true;
    m_projectedUtilizationMetrics = std::forward<ProjectedUtilizationMetricsT>(value);
  }
  template <typename ProjectedUtilizationMetricsT = Aws::Vector<UtilizationMetric>>
  InstanceRecommendationOption& WithProjectedUtilizationMetrics(ProjectedUtilizationMetricsT&& value) {
    SetProjectedUtilizationMetrics(std::forward<ProjectedUtilizationMetricsT>(value));
    return *this;
  }
  template <typename ProjectedUtilizationMetricsT = UtilizationMetric>
  InstanceRecommendationOption& AddProjectedUtilizationMetrics(ProjectedUtilizationMetricsT&& value) {
    m_projectedUtilizationMetricsHasBeenSet = true;
    m_projectedUtilizationMetrics.emplace_back(std::forward<ProjectedUtilizationMetricsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<PlatformDifference>& GetPlatformDifferences() const { return m_platformDifferences; }
  inline bool PlatformDifferencesHasBeenSet() const { return m_platformDifferencesHasBeenSet; }
  template <typename PlatformDifferencesT = Aws::Vector<PlatformDifference>>
  void SetPlatformDifferences(PlatformDifferencesT&& value) {
    m_platformDifferencesHasBeenSet = true;
    m_platformDifferences = std::forward<PlatformDifferencesT>(value);
  }
  template <typename PlatformDifferencesT = Aws::Vector<PlatformDifference>>
  InstanceRecommendationOption& WithPlatformDifferences(PlatformDifferencesT&& value) {
    SetPlatformDifferences(std::forward<PlatformDifferencesT>(value));
    return *this;
  }
  inline InstanceRecommendationOption& AddPlatformDifferences(PlatformDifference value) {
    m_platformDifferencesHasBeenSet = true;
    m_platformDifferences.push_back(value);
    return *this;
  }
 
 
  inline double GetPerformanceRisk() const { return m_performanceRisk; }
  inline bool PerformanceRiskHasBeenSet() const { return m_performanceRiskHasBeenSet; }
  inline void SetPerformanceRisk(double value) {
    m_performanceRiskHasBeenSet = true;
    m_performanceRisk = value;
  }
  inline InstanceRecommendationOption& WithPerformanceRisk(double value) {
    SetPerformanceRisk(value);
    return *this;
  }
 
 
  inline int GetRank() const { return m_rank; }
  inline bool RankHasBeenSet() const { return m_rankHasBeenSet; }
  inline void SetRank(int value) {
    m_rankHasBeenSet = true;
    m_rank = value;
  }
  inline InstanceRecommendationOption& WithRank(int value) {
    SetRank(value);
    return *this;
  }
 
 
  inline const SavingsOpportunity& GetSavingsOpportunity() const { return m_savingsOpportunity; }
  inline bool SavingsOpportunityHasBeenSet() const { return m_savingsOpportunityHasBeenSet; }
  template <typename SavingsOpportunityT = SavingsOpportunity>
  void SetSavingsOpportunity(SavingsOpportunityT&& value) {
    m_savingsOpportunityHasBeenSet = true;
    m_savingsOpportunity = std::forward<SavingsOpportunityT>(value);
  }
  template <typename SavingsOpportunityT = SavingsOpportunity>
  InstanceRecommendationOption& WithSavingsOpportunity(SavingsOpportunityT&& value) {
    SetSavingsOpportunity(std::forward<SavingsOpportunityT>(value));
    return *this;
  }
 
 
  inline const InstanceSavingsOpportunityAfterDiscounts& GetSavingsOpportunityAfterDiscounts() const {
    return m_savingsOpportunityAfterDiscounts;
  }
  inline bool SavingsOpportunityAfterDiscountsHasBeenSet() const { return m_savingsOpportunityAfterDiscountsHasBeenSet; }
  template <typename SavingsOpportunityAfterDiscountsT = InstanceSavingsOpportunityAfterDiscounts>
  void SetSavingsOpportunityAfterDiscounts(SavingsOpportunityAfterDiscountsT&& value) {
    m_savingsOpportunityAfterDiscountsHasBeenSet = true;
    m_savingsOpportunityAfterDiscounts = std::forward<SavingsOpportunityAfterDiscountsT>(value);
  }
  template <typename SavingsOpportunityAfterDiscountsT = InstanceSavingsOpportunityAfterDiscounts>
  InstanceRecommendationOption& WithSavingsOpportunityAfterDiscounts(SavingsOpportunityAfterDiscountsT&& value) {
    SetSavingsOpportunityAfterDiscounts(std::forward<SavingsOpportunityAfterDiscountsT>(value));
    return *this;
  }
 
 
  inline MigrationEffort GetMigrationEffort() const { return m_migrationEffort; }
  inline bool MigrationEffortHasBeenSet() const { return m_migrationEffortHasBeenSet; }
  inline void SetMigrationEffort(MigrationEffort value) {
    m_migrationEffortHasBeenSet = true;
    m_migrationEffort = value;
  }
  inline InstanceRecommendationOption& WithMigrationEffort(MigrationEffort value) {
    SetMigrationEffort(value);
    return *this;
  }
 private:
  Aws::String m_instanceType;
 
  GpuInfo m_instanceGpuInfo;
 
  Aws::Vector<UtilizationMetric> m_projectedUtilizationMetrics;
 
  Aws::Vector<PlatformDifference> m_platformDifferences;
 
  double m_performanceRisk{0.0};
 
  int m_rank{0};
 
  SavingsOpportunity m_savingsOpportunity;
 
  InstanceSavingsOpportunityAfterDiscounts m_savingsOpportunityAfterDiscounts;
 
  MigrationEffort m_migrationEffort{MigrationEffort::NOT_SET};
  bool m_instanceTypeHasBeenSet = false;
  bool m_instanceGpuInfoHasBeenSet = false;
  bool m_projectedUtilizationMetricsHasBeenSet = false;
  bool m_platformDifferencesHasBeenSet = false;
  bool m_performanceRiskHasBeenSet = false;
  bool m_rankHasBeenSet = false;
  bool m_savingsOpportunityHasBeenSet = false;
  bool m_savingsOpportunityAfterDiscountsHasBeenSet = false;
  bool m_migrationEffortHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ComputeOptimizer
}  // namespace Aws