NodeRangeProperty.h

 
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/batch/model/ConsumableResourceProperties.h>
#include <aws/batch/model/ContainerProperties.h>
#include <aws/batch/model/EcsProperties.h>
#include <aws/batch/model/EksProperties.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 Batch {
namespace Model {
 
class NodeRangeProperty {
 public:
  AWS_BATCH_API NodeRangeProperty() = default;
  AWS_BATCH_API NodeRangeProperty(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API NodeRangeProperty& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetTargetNodes() const { return m_targetNodes; }
  inline bool TargetNodesHasBeenSet() const { return m_targetNodesHasBeenSet; }
  template <typename TargetNodesT = Aws::String>
  void SetTargetNodes(TargetNodesT&& value) {
    m_targetNodesHasBeenSet = true;
    m_targetNodes = std::forward<TargetNodesT>(value);
  }
  template <typename TargetNodesT = Aws::String>
  NodeRangeProperty& WithTargetNodes(TargetNodesT&& value) {
    SetTargetNodes(std::forward<TargetNodesT>(value));
    return *this;
  }
 
 
  inline const ContainerProperties& GetContainer() const { return m_container; }
  inline bool ContainerHasBeenSet() const { return m_containerHasBeenSet; }
  template <typename ContainerT = ContainerProperties>
  void SetContainer(ContainerT&& value) {
    m_containerHasBeenSet = true;
    m_container = std::forward<ContainerT>(value);
  }
  template <typename ContainerT = ContainerProperties>
  NodeRangeProperty& WithContainer(ContainerT&& value) {
    SetContainer(std::forward<ContainerT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetInstanceTypes() const { return m_instanceTypes; }
  inline bool InstanceTypesHasBeenSet() const { return m_instanceTypesHasBeenSet; }
  template <typename InstanceTypesT = Aws::Vector<Aws::String>>
  void SetInstanceTypes(InstanceTypesT&& value) {
    m_instanceTypesHasBeenSet = true;
    m_instanceTypes = std::forward<InstanceTypesT>(value);
  }
  template <typename InstanceTypesT = Aws::Vector<Aws::String>>
  NodeRangeProperty& WithInstanceTypes(InstanceTypesT&& value) {
    SetInstanceTypes(std::forward<InstanceTypesT>(value));
    return *this;
  }
  template <typename InstanceTypesT = Aws::String>
  NodeRangeProperty& AddInstanceTypes(InstanceTypesT&& value) {
    m_instanceTypesHasBeenSet = true;
    m_instanceTypes.emplace_back(std::forward<InstanceTypesT>(value));
    return *this;
  }
 
 
  inline const EcsProperties& GetEcsProperties() const { return m_ecsProperties; }
  inline bool EcsPropertiesHasBeenSet() const { return m_ecsPropertiesHasBeenSet; }
  template <typename EcsPropertiesT = EcsProperties>
  void SetEcsProperties(EcsPropertiesT&& value) {
    m_ecsPropertiesHasBeenSet = true;
    m_ecsProperties = std::forward<EcsPropertiesT>(value);
  }
  template <typename EcsPropertiesT = EcsProperties>
  NodeRangeProperty& WithEcsProperties(EcsPropertiesT&& value) {
    SetEcsProperties(std::forward<EcsPropertiesT>(value));
    return *this;
  }
 
 
  inline const EksProperties& GetEksProperties() const { return m_eksProperties; }
  inline bool EksPropertiesHasBeenSet() const { return m_eksPropertiesHasBeenSet; }
  template <typename EksPropertiesT = EksProperties>
  void SetEksProperties(EksPropertiesT&& value) {
    m_eksPropertiesHasBeenSet = true;
    m_eksProperties = std::forward<EksPropertiesT>(value);
  }
  template <typename EksPropertiesT = EksProperties>
  NodeRangeProperty& WithEksProperties(EksPropertiesT&& value) {
    SetEksProperties(std::forward<EksPropertiesT>(value));
    return *this;
  }
 
 
  inline const ConsumableResourceProperties& GetConsumableResourceProperties() const { return m_consumableResourceProperties; }
  inline bool ConsumableResourcePropertiesHasBeenSet() const { return m_consumableResourcePropertiesHasBeenSet; }
  template <typename ConsumableResourcePropertiesT = ConsumableResourceProperties>
  void SetConsumableResourceProperties(ConsumableResourcePropertiesT&& value) {
    m_consumableResourcePropertiesHasBeenSet = true;
    m_consumableResourceProperties = std::forward<ConsumableResourcePropertiesT>(value);
  }
  template <typename ConsumableResourcePropertiesT = ConsumableResourceProperties>
  NodeRangeProperty& WithConsumableResourceProperties(ConsumableResourcePropertiesT&& value) {
    SetConsumableResourceProperties(std::forward<ConsumableResourcePropertiesT>(value));
    return *this;
  }
 private:
  Aws::String m_targetNodes;
 
  ContainerProperties m_container;
 
  Aws::Vector<Aws::String> m_instanceTypes;
 
  EcsProperties m_ecsProperties;
 
  EksProperties m_eksProperties;
 
  ConsumableResourceProperties m_consumableResourceProperties;
  bool m_targetNodesHasBeenSet = false;
  bool m_containerHasBeenSet = false;
  bool m_instanceTypesHasBeenSet = false;
  bool m_ecsPropertiesHasBeenSet = false;
  bool m_eksPropertiesHasBeenSet = false;
  bool m_consumableResourcePropertiesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Batch
}  // namespace Aws