SavingsPlansUtilizationByTime.h

 
#pragma once
#include <aws/ce/CostExplorer_EXPORTS.h>
#include <aws/ce/model/DateInterval.h>
#include <aws/ce/model/SavingsPlansAmortizedCommitment.h>
#include <aws/ce/model/SavingsPlansSavings.h>
#include <aws/ce/model/SavingsPlansUtilization.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace CostExplorer {
namespace Model {
 
class SavingsPlansUtilizationByTime {
 public:
  AWS_COSTEXPLORER_API SavingsPlansUtilizationByTime() = default;
  AWS_COSTEXPLORER_API SavingsPlansUtilizationByTime(Aws::Utils::Json::JsonView jsonValue);
  AWS_COSTEXPLORER_API SavingsPlansUtilizationByTime& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_COSTEXPLORER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const DateInterval& GetTimePeriod() const { return m_timePeriod; }
  inline bool TimePeriodHasBeenSet() const { return m_timePeriodHasBeenSet; }
  template <typename TimePeriodT = DateInterval>
  void SetTimePeriod(TimePeriodT&& value) {
    m_timePeriodHasBeenSet = true;
    m_timePeriod = std::forward<TimePeriodT>(value);
  }
  template <typename TimePeriodT = DateInterval>
  SavingsPlansUtilizationByTime& WithTimePeriod(TimePeriodT&& value) {
    SetTimePeriod(std::forward<TimePeriodT>(value));
    return *this;
  }
 
 
  inline const SavingsPlansUtilization& GetUtilization() const { return m_utilization; }
  inline bool UtilizationHasBeenSet() const { return m_utilizationHasBeenSet; }
  template <typename UtilizationT = SavingsPlansUtilization>
  void SetUtilization(UtilizationT&& value) {
    m_utilizationHasBeenSet = true;
    m_utilization = std::forward<UtilizationT>(value);
  }
  template <typename UtilizationT = SavingsPlansUtilization>
  SavingsPlansUtilizationByTime& WithUtilization(UtilizationT&& value) {
    SetUtilization(std::forward<UtilizationT>(value));
    return *this;
  }
 
 
  inline const SavingsPlansSavings& GetSavings() const { return m_savings; }
  inline bool SavingsHasBeenSet() const { return m_savingsHasBeenSet; }
  template <typename SavingsT = SavingsPlansSavings>
  void SetSavings(SavingsT&& value) {
    m_savingsHasBeenSet = true;
    m_savings = std::forward<SavingsT>(value);
  }
  template <typename SavingsT = SavingsPlansSavings>
  SavingsPlansUtilizationByTime& WithSavings(SavingsT&& value) {
    SetSavings(std::forward<SavingsT>(value));
    return *this;
  }
 
 
  inline const SavingsPlansAmortizedCommitment& GetAmortizedCommitment() const { return m_amortizedCommitment; }
  inline bool AmortizedCommitmentHasBeenSet() const { return m_amortizedCommitmentHasBeenSet; }
  template <typename AmortizedCommitmentT = SavingsPlansAmortizedCommitment>
  void SetAmortizedCommitment(AmortizedCommitmentT&& value) {
    m_amortizedCommitmentHasBeenSet = true;
    m_amortizedCommitment = std::forward<AmortizedCommitmentT>(value);
  }
  template <typename AmortizedCommitmentT = SavingsPlansAmortizedCommitment>
  SavingsPlansUtilizationByTime& WithAmortizedCommitment(AmortizedCommitmentT&& value) {
    SetAmortizedCommitment(std::forward<AmortizedCommitmentT>(value));
    return *this;
  }
 private:
  DateInterval m_timePeriod;
 
  SavingsPlansUtilization m_utilization;
 
  SavingsPlansSavings m_savings;
 
  SavingsPlansAmortizedCommitment m_amortizedCommitment;
  bool m_timePeriodHasBeenSet = false;
  bool m_utilizationHasBeenSet = false;
  bool m_savingsHasBeenSet = false;
  bool m_amortizedCommitmentHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace CostExplorer
}  // namespace Aws