WeightedBalancedSchedulingConfiguration.h

 
#pragma once
#include <aws/deadline/Deadline_EXPORTS.h>
#include <aws/deadline/model/SchedulingMaxPriorityOverride.h>
#include <aws/deadline/model/SchedulingMinPriorityOverride.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace deadline {
namespace Model {
 
class WeightedBalancedSchedulingConfiguration {
 public:
  AWS_DEADLINE_API WeightedBalancedSchedulingConfiguration() = default;
  AWS_DEADLINE_API WeightedBalancedSchedulingConfiguration(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEADLINE_API WeightedBalancedSchedulingConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEADLINE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline double GetPriorityWeight() const { return m_priorityWeight; }
  inline bool PriorityWeightHasBeenSet() const { return m_priorityWeightHasBeenSet; }
  inline void SetPriorityWeight(double value) {
    m_priorityWeightHasBeenSet = true;
    m_priorityWeight = value;
  }
  inline WeightedBalancedSchedulingConfiguration& WithPriorityWeight(double value) {
    SetPriorityWeight(value);
    return *this;
  }
 
 
  inline double GetErrorWeight() const { return m_errorWeight; }
  inline bool ErrorWeightHasBeenSet() const { return m_errorWeightHasBeenSet; }
  inline void SetErrorWeight(double value) {
    m_errorWeightHasBeenSet = true;
    m_errorWeight = value;
  }
  inline WeightedBalancedSchedulingConfiguration& WithErrorWeight(double value) {
    SetErrorWeight(value);
    return *this;
  }
 
 
  inline double GetSubmissionTimeWeight() const { return m_submissionTimeWeight; }
  inline bool SubmissionTimeWeightHasBeenSet() const { return m_submissionTimeWeightHasBeenSet; }
  inline void SetSubmissionTimeWeight(double value) {
    m_submissionTimeWeightHasBeenSet = true;
    m_submissionTimeWeight = value;
  }
  inline WeightedBalancedSchedulingConfiguration& WithSubmissionTimeWeight(double value) {
    SetSubmissionTimeWeight(value);
    return *this;
  }
 
 
  inline double GetRenderingTaskWeight() const { return m_renderingTaskWeight; }
  inline bool RenderingTaskWeightHasBeenSet() const { return m_renderingTaskWeightHasBeenSet; }
  inline void SetRenderingTaskWeight(double value) {
    m_renderingTaskWeightHasBeenSet = true;
    m_renderingTaskWeight = value;
  }
  inline WeightedBalancedSchedulingConfiguration& WithRenderingTaskWeight(double value) {
    SetRenderingTaskWeight(value);
    return *this;
  }
 
 
  inline int GetRenderingTaskBuffer() const { return m_renderingTaskBuffer; }
  inline bool RenderingTaskBufferHasBeenSet() const { return m_renderingTaskBufferHasBeenSet; }
  inline void SetRenderingTaskBuffer(int value) {
    m_renderingTaskBufferHasBeenSet = true;
    m_renderingTaskBuffer = value;
  }
  inline WeightedBalancedSchedulingConfiguration& WithRenderingTaskBuffer(int value) {
    SetRenderingTaskBuffer(value);
    return *this;
  }
 
 
  inline const SchedulingMaxPriorityOverride& GetMaxPriorityOverride() const { return m_maxPriorityOverride; }
  inline bool MaxPriorityOverrideHasBeenSet() const { return m_maxPriorityOverrideHasBeenSet; }
  template <typename MaxPriorityOverrideT = SchedulingMaxPriorityOverride>
  void SetMaxPriorityOverride(MaxPriorityOverrideT&& value) {
    m_maxPriorityOverrideHasBeenSet = true;
    m_maxPriorityOverride = std::forward<MaxPriorityOverrideT>(value);
  }
  template <typename MaxPriorityOverrideT = SchedulingMaxPriorityOverride>
  WeightedBalancedSchedulingConfiguration& WithMaxPriorityOverride(MaxPriorityOverrideT&& value) {
    SetMaxPriorityOverride(std::forward<MaxPriorityOverrideT>(value));
    return *this;
  }
 
 
  inline const SchedulingMinPriorityOverride& GetMinPriorityOverride() const { return m_minPriorityOverride; }
  inline bool MinPriorityOverrideHasBeenSet() const { return m_minPriorityOverrideHasBeenSet; }
  template <typename MinPriorityOverrideT = SchedulingMinPriorityOverride>
  void SetMinPriorityOverride(MinPriorityOverrideT&& value) {
    m_minPriorityOverrideHasBeenSet = true;
    m_minPriorityOverride = std::forward<MinPriorityOverrideT>(value);
  }
  template <typename MinPriorityOverrideT = SchedulingMinPriorityOverride>
  WeightedBalancedSchedulingConfiguration& WithMinPriorityOverride(MinPriorityOverrideT&& value) {
    SetMinPriorityOverride(std::forward<MinPriorityOverrideT>(value));
    return *this;
  }
 private:
  double m_priorityWeight{0.0};
 
  double m_errorWeight{0.0};
 
  double m_submissionTimeWeight{0.0};
 
  double m_renderingTaskWeight{0.0};
 
  int m_renderingTaskBuffer{0};
 
  SchedulingMaxPriorityOverride m_maxPriorityOverride;
 
  SchedulingMinPriorityOverride m_minPriorityOverride;
  bool m_priorityWeightHasBeenSet = false;
  bool m_errorWeightHasBeenSet = false;
  bool m_submissionTimeWeightHasBeenSet = false;
  bool m_renderingTaskWeightHasBeenSet = false;
  bool m_renderingTaskBufferHasBeenSet = false;
  bool m_maxPriorityOverrideHasBeenSet = false;
  bool m_minPriorityOverrideHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace deadline
}  // namespace Aws