Statistics.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/deadline/Deadline_EXPORTS.h>
#include <aws/deadline/model/Stats.h>
#include <aws/deadline/model/UsageType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace deadline {
namespace Model {
 
class Statistics {
 public:
  AWS_DEADLINE_API Statistics() = default;
  AWS_DEADLINE_API Statistics(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEADLINE_API Statistics& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEADLINE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetQueueId() const { return m_queueId; }
  inline bool QueueIdHasBeenSet() const { return m_queueIdHasBeenSet; }
  template <typename QueueIdT = Aws::String>
  void SetQueueId(QueueIdT&& value) {
    m_queueIdHasBeenSet = true;
    m_queueId = std::forward<QueueIdT>(value);
  }
  template <typename QueueIdT = Aws::String>
  Statistics& WithQueueId(QueueIdT&& value) {
    SetQueueId(std::forward<QueueIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFleetId() const { return m_fleetId; }
  inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
  template <typename FleetIdT = Aws::String>
  void SetFleetId(FleetIdT&& value) {
    m_fleetIdHasBeenSet = true;
    m_fleetId = std::forward<FleetIdT>(value);
  }
  template <typename FleetIdT = Aws::String>
  Statistics& WithFleetId(FleetIdT&& value) {
    SetFleetId(std::forward<FleetIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetJobId() const { return m_jobId; }
  inline bool JobIdHasBeenSet() const { return m_jobIdHasBeenSet; }
  template <typename JobIdT = Aws::String>
  void SetJobId(JobIdT&& value) {
    m_jobIdHasBeenSet = true;
    m_jobId = std::forward<JobIdT>(value);
  }
  template <typename JobIdT = Aws::String>
  Statistics& WithJobId(JobIdT&& value) {
    SetJobId(std::forward<JobIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetJobName() const { return m_jobName; }
  inline bool JobNameHasBeenSet() const { return m_jobNameHasBeenSet; }
  template <typename JobNameT = Aws::String>
  void SetJobName(JobNameT&& value) {
    m_jobNameHasBeenSet = true;
    m_jobName = std::forward<JobNameT>(value);
  }
  template <typename JobNameT = Aws::String>
  Statistics& WithJobName(JobNameT&& value) {
    SetJobName(std::forward<JobNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUserId() const { return m_userId; }
  inline bool UserIdHasBeenSet() const { return m_userIdHasBeenSet; }
  template <typename UserIdT = Aws::String>
  void SetUserId(UserIdT&& value) {
    m_userIdHasBeenSet = true;
    m_userId = std::forward<UserIdT>(value);
  }
  template <typename UserIdT = Aws::String>
  Statistics& WithUserId(UserIdT&& value) {
    SetUserId(std::forward<UserIdT>(value));
    return *this;
  }
 
 
  inline UsageType GetUsageType() const { return m_usageType; }
  inline bool UsageTypeHasBeenSet() const { return m_usageTypeHasBeenSet; }
  inline void SetUsageType(UsageType value) {
    m_usageTypeHasBeenSet = true;
    m_usageType = value;
  }
  inline Statistics& WithUsageType(UsageType value) {
    SetUsageType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLicenseProduct() const { return m_licenseProduct; }
  inline bool LicenseProductHasBeenSet() const { return m_licenseProductHasBeenSet; }
  template <typename LicenseProductT = Aws::String>
  void SetLicenseProduct(LicenseProductT&& value) {
    m_licenseProductHasBeenSet = true;
    m_licenseProduct = std::forward<LicenseProductT>(value);
  }
  template <typename LicenseProductT = Aws::String>
  Statistics& WithLicenseProduct(LicenseProductT&& value) {
    SetLicenseProduct(std::forward<LicenseProductT>(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>
  Statistics& WithInstanceType(InstanceTypeT&& value) {
    SetInstanceType(std::forward<InstanceTypeT>(value));
    return *this;
  }
 
 
  inline int GetCount() const { return m_count; }
  inline bool CountHasBeenSet() const { return m_countHasBeenSet; }
  inline void SetCount(int value) {
    m_countHasBeenSet = true;
    m_count = value;
  }
  inline Statistics& WithCount(int value) {
    SetCount(value);
    return *this;
  }
 
 
  inline const Stats& GetCostInUsd() const { return m_costInUsd; }
  inline bool CostInUsdHasBeenSet() const { return m_costInUsdHasBeenSet; }
  template <typename CostInUsdT = Stats>
  void SetCostInUsd(CostInUsdT&& value) {
    m_costInUsdHasBeenSet = true;
    m_costInUsd = std::forward<CostInUsdT>(value);
  }
  template <typename CostInUsdT = Stats>
  Statistics& WithCostInUsd(CostInUsdT&& value) {
    SetCostInUsd(std::forward<CostInUsdT>(value));
    return *this;
  }
 
 
  inline const Stats& GetRuntimeInSeconds() const { return m_runtimeInSeconds; }
  inline bool RuntimeInSecondsHasBeenSet() const { return m_runtimeInSecondsHasBeenSet; }
  template <typename RuntimeInSecondsT = Stats>
  void SetRuntimeInSeconds(RuntimeInSecondsT&& value) {
    m_runtimeInSecondsHasBeenSet = true;
    m_runtimeInSeconds = std::forward<RuntimeInSecondsT>(value);
  }
  template <typename RuntimeInSecondsT = Stats>
  Statistics& WithRuntimeInSeconds(RuntimeInSecondsT&& value) {
    SetRuntimeInSeconds(std::forward<RuntimeInSecondsT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetAggregationStartTime() const { return m_aggregationStartTime; }
  inline bool AggregationStartTimeHasBeenSet() const { return m_aggregationStartTimeHasBeenSet; }
  template <typename AggregationStartTimeT = Aws::Utils::DateTime>
  void SetAggregationStartTime(AggregationStartTimeT&& value) {
    m_aggregationStartTimeHasBeenSet = true;
    m_aggregationStartTime = std::forward<AggregationStartTimeT>(value);
  }
  template <typename AggregationStartTimeT = Aws::Utils::DateTime>
  Statistics& WithAggregationStartTime(AggregationStartTimeT&& value) {
    SetAggregationStartTime(std::forward<AggregationStartTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetAggregationEndTime() const { return m_aggregationEndTime; }
  inline bool AggregationEndTimeHasBeenSet() const { return m_aggregationEndTimeHasBeenSet; }
  template <typename AggregationEndTimeT = Aws::Utils::DateTime>
  void SetAggregationEndTime(AggregationEndTimeT&& value) {
    m_aggregationEndTimeHasBeenSet = true;
    m_aggregationEndTime = std::forward<AggregationEndTimeT>(value);
  }
  template <typename AggregationEndTimeT = Aws::Utils::DateTime>
  Statistics& WithAggregationEndTime(AggregationEndTimeT&& value) {
    SetAggregationEndTime(std::forward<AggregationEndTimeT>(value));
    return *this;
  }
 private:
  Aws::String m_queueId;
 
  Aws::String m_fleetId;
 
  Aws::String m_jobId;
 
  Aws::String m_jobName;
 
  Aws::String m_userId;
 
  UsageType m_usageType{UsageType::NOT_SET};
 
  Aws::String m_licenseProduct;
 
  Aws::String m_instanceType;
 
  int m_count{0};
 
  Stats m_costInUsd;
 
  Stats m_runtimeInSeconds;
 
  Aws::Utils::DateTime m_aggregationStartTime{};
 
  Aws::Utils::DateTime m_aggregationEndTime{};
  bool m_queueIdHasBeenSet = false;
  bool m_fleetIdHasBeenSet = false;
  bool m_jobIdHasBeenSet = false;
  bool m_jobNameHasBeenSet = false;
  bool m_userIdHasBeenSet = false;
  bool m_usageTypeHasBeenSet = false;
  bool m_licenseProductHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_countHasBeenSet = false;
  bool m_costInUsdHasBeenSet = false;
  bool m_runtimeInSecondsHasBeenSet = false;
  bool m_aggregationStartTimeHasBeenSet = false;
  bool m_aggregationEndTimeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace deadline
}  // namespace Aws