RegisterJobDefinitionRequest.h

 
#pragma once
#include <aws/batch/BatchRequest.h>
#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/batch/model/JobDefinitionType.h>
#include <aws/batch/model/JobTimeout.h>
#include <aws/batch/model/NodeProperties.h>
#include <aws/batch/model/PlatformCapability.h>
#include <aws/batch/model/RetryStrategy.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Batch {
namespace Model {
 
class RegisterJobDefinitionRequest : public BatchRequest {
 public:
  AWS_BATCH_API RegisterJobDefinitionRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "RegisterJobDefinition"; }
 
  AWS_BATCH_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetJobDefinitionName() const { return m_jobDefinitionName; }
  inline bool JobDefinitionNameHasBeenSet() const { return m_jobDefinitionNameHasBeenSet; }
  template <typename JobDefinitionNameT = Aws::String>
  void SetJobDefinitionName(JobDefinitionNameT&& value) {
    m_jobDefinitionNameHasBeenSet = true;
    m_jobDefinitionName = std::forward<JobDefinitionNameT>(value);
  }
  template <typename JobDefinitionNameT = Aws::String>
  RegisterJobDefinitionRequest& WithJobDefinitionName(JobDefinitionNameT&& value) {
    SetJobDefinitionName(std::forward<JobDefinitionNameT>(value));
    return *this;
  }
 
 
  inline JobDefinitionType GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(JobDefinitionType value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline RegisterJobDefinitionRequest& WithType(JobDefinitionType value) {
    SetType(value);
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetParameters() const { return m_parameters; }
  inline bool ParametersHasBeenSet() const { return m_parametersHasBeenSet; }
  template <typename ParametersT = Aws::Map<Aws::String, Aws::String>>
  void SetParameters(ParametersT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters = std::forward<ParametersT>(value);
  }
  template <typename ParametersT = Aws::Map<Aws::String, Aws::String>>
  RegisterJobDefinitionRequest& WithParameters(ParametersT&& value) {
    SetParameters(std::forward<ParametersT>(value));
    return *this;
  }
  template <typename ParametersKeyT = Aws::String, typename ParametersValueT = Aws::String>
  RegisterJobDefinitionRequest& AddParameters(ParametersKeyT&& key, ParametersValueT&& value) {
    m_parametersHasBeenSet = true;
    m_parameters.emplace(std::forward<ParametersKeyT>(key), std::forward<ParametersValueT>(value));
    return *this;
  }
 
 
  inline int GetSchedulingPriority() const { return m_schedulingPriority; }
  inline bool SchedulingPriorityHasBeenSet() const { return m_schedulingPriorityHasBeenSet; }
  inline void SetSchedulingPriority(int value) {
    m_schedulingPriorityHasBeenSet = true;
    m_schedulingPriority = value;
  }
  inline RegisterJobDefinitionRequest& WithSchedulingPriority(int value) {
    SetSchedulingPriority(value);
    return *this;
  }
 
 
  inline const ContainerProperties& GetContainerProperties() const { return m_containerProperties; }
  inline bool ContainerPropertiesHasBeenSet() const { return m_containerPropertiesHasBeenSet; }
  template <typename ContainerPropertiesT = ContainerProperties>
  void SetContainerProperties(ContainerPropertiesT&& value) {
    m_containerPropertiesHasBeenSet = true;
    m_containerProperties = std::forward<ContainerPropertiesT>(value);
  }
  template <typename ContainerPropertiesT = ContainerProperties>
  RegisterJobDefinitionRequest& WithContainerProperties(ContainerPropertiesT&& value) {
    SetContainerProperties(std::forward<ContainerPropertiesT>(value));
    return *this;
  }
 
 
  inline const NodeProperties& GetNodeProperties() const { return m_nodeProperties; }
  inline bool NodePropertiesHasBeenSet() const { return m_nodePropertiesHasBeenSet; }
  template <typename NodePropertiesT = NodeProperties>
  void SetNodeProperties(NodePropertiesT&& value) {
    m_nodePropertiesHasBeenSet = true;
    m_nodeProperties = std::forward<NodePropertiesT>(value);
  }
  template <typename NodePropertiesT = NodeProperties>
  RegisterJobDefinitionRequest& WithNodeProperties(NodePropertiesT&& value) {
    SetNodeProperties(std::forward<NodePropertiesT>(value));
    return *this;
  }
 
 
  inline const RetryStrategy& GetRetryStrategy() const { return m_retryStrategy; }
  inline bool RetryStrategyHasBeenSet() const { return m_retryStrategyHasBeenSet; }
  template <typename RetryStrategyT = RetryStrategy>
  void SetRetryStrategy(RetryStrategyT&& value) {
    m_retryStrategyHasBeenSet = true;
    m_retryStrategy = std::forward<RetryStrategyT>(value);
  }
  template <typename RetryStrategyT = RetryStrategy>
  RegisterJobDefinitionRequest& WithRetryStrategy(RetryStrategyT&& value) {
    SetRetryStrategy(std::forward<RetryStrategyT>(value));
    return *this;
  }
 
 
  inline bool GetPropagateTags() const { return m_propagateTags; }
  inline bool PropagateTagsHasBeenSet() const { return m_propagateTagsHasBeenSet; }
  inline void SetPropagateTags(bool value) {
    m_propagateTagsHasBeenSet = true;
    m_propagateTags = value;
  }
  inline RegisterJobDefinitionRequest& WithPropagateTags(bool value) {
    SetPropagateTags(value);
    return *this;
  }
 
 
  inline const JobTimeout& GetTimeout() const { return m_timeout; }
  inline bool TimeoutHasBeenSet() const { return m_timeoutHasBeenSet; }
  template <typename TimeoutT = JobTimeout>
  void SetTimeout(TimeoutT&& value) {
    m_timeoutHasBeenSet = true;
    m_timeout = std::forward<TimeoutT>(value);
  }
  template <typename TimeoutT = JobTimeout>
  RegisterJobDefinitionRequest& WithTimeout(TimeoutT&& value) {
    SetTimeout(std::forward<TimeoutT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  RegisterJobDefinitionRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  RegisterJobDefinitionRequest& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<PlatformCapability>& GetPlatformCapabilities() const { return m_platformCapabilities; }
  inline bool PlatformCapabilitiesHasBeenSet() const { return m_platformCapabilitiesHasBeenSet; }
  template <typename PlatformCapabilitiesT = Aws::Vector<PlatformCapability>>
  void SetPlatformCapabilities(PlatformCapabilitiesT&& value) {
    m_platformCapabilitiesHasBeenSet = true;
    m_platformCapabilities = std::forward<PlatformCapabilitiesT>(value);
  }
  template <typename PlatformCapabilitiesT = Aws::Vector<PlatformCapability>>
  RegisterJobDefinitionRequest& WithPlatformCapabilities(PlatformCapabilitiesT&& value) {
    SetPlatformCapabilities(std::forward<PlatformCapabilitiesT>(value));
    return *this;
  }
  inline RegisterJobDefinitionRequest& AddPlatformCapabilities(PlatformCapability value) {
    m_platformCapabilitiesHasBeenSet = true;
    m_platformCapabilities.push_back(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>
  RegisterJobDefinitionRequest& WithEksProperties(EksPropertiesT&& value) {
    SetEksProperties(std::forward<EksPropertiesT>(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>
  RegisterJobDefinitionRequest& WithEcsProperties(EcsPropertiesT&& value) {
    SetEcsProperties(std::forward<EcsPropertiesT>(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>
  RegisterJobDefinitionRequest& WithConsumableResourceProperties(ConsumableResourcePropertiesT&& value) {
    SetConsumableResourceProperties(std::forward<ConsumableResourcePropertiesT>(value));
    return *this;
  }
 private:
  Aws::String m_jobDefinitionName;
 
  JobDefinitionType m_type{JobDefinitionType::NOT_SET};
 
  Aws::Map<Aws::String, Aws::String> m_parameters;
 
  int m_schedulingPriority{0};
 
  ContainerProperties m_containerProperties;
 
  NodeProperties m_nodeProperties;
 
  RetryStrategy m_retryStrategy;
 
  bool m_propagateTags{false};
 
  JobTimeout m_timeout;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::Vector<PlatformCapability> m_platformCapabilities;
 
  EksProperties m_eksProperties;
 
  EcsProperties m_ecsProperties;
 
  ConsumableResourceProperties m_consumableResourceProperties;
  bool m_jobDefinitionNameHasBeenSet = false;
  bool m_typeHasBeenSet = false;
  bool m_parametersHasBeenSet = false;
  bool m_schedulingPriorityHasBeenSet = false;
  bool m_containerPropertiesHasBeenSet = false;
  bool m_nodePropertiesHasBeenSet = false;
  bool m_retryStrategyHasBeenSet = false;
  bool m_propagateTagsHasBeenSet = false;
  bool m_timeoutHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_platformCapabilitiesHasBeenSet = false;
  bool m_eksPropertiesHasBeenSet = false;
  bool m_ecsPropertiesHasBeenSet = false;
  bool m_consumableResourcePropertiesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Batch
}  // namespace Aws