StartTaskRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/ECSRequest.h>
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/ecs/model/NetworkConfiguration.h>
#include <aws/ecs/model/PropagateTags.h>
#include <aws/ecs/model/Tag.h>
#include <aws/ecs/model/TaskOverride.h>
#include <aws/ecs/model/TaskVolumeConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace ECS {
namespace Model {
 
class StartTaskRequest : public ECSRequest {
 public:
  AWS_ECS_API StartTaskRequest() = 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 "StartTask"; }
 
  AWS_ECS_API Aws::String SerializePayload() const override;
 
  AWS_ECS_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  inline const Aws::String& GetCluster() const { return m_cluster; }
  inline bool ClusterHasBeenSet() const { return m_clusterHasBeenSet; }
  template <typename ClusterT = Aws::String>
  void SetCluster(ClusterT&& value) {
    m_clusterHasBeenSet = true;
    m_cluster = std::forward<ClusterT>(value);
  }
  template <typename ClusterT = Aws::String>
  StartTaskRequest& WithCluster(ClusterT&& value) {
    SetCluster(std::forward<ClusterT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetContainerInstances() const { return m_containerInstances; }
  inline bool ContainerInstancesHasBeenSet() const { return m_containerInstancesHasBeenSet; }
  template <typename ContainerInstancesT = Aws::Vector<Aws::String>>
  void SetContainerInstances(ContainerInstancesT&& value) {
    m_containerInstancesHasBeenSet = true;
    m_containerInstances = std::forward<ContainerInstancesT>(value);
  }
  template <typename ContainerInstancesT = Aws::Vector<Aws::String>>
  StartTaskRequest& WithContainerInstances(ContainerInstancesT&& value) {
    SetContainerInstances(std::forward<ContainerInstancesT>(value));
    return *this;
  }
  template <typename ContainerInstancesT = Aws::String>
  StartTaskRequest& AddContainerInstances(ContainerInstancesT&& value) {
    m_containerInstancesHasBeenSet = true;
    m_containerInstances.emplace_back(std::forward<ContainerInstancesT>(value));
    return *this;
  }
 
 
  inline bool GetEnableECSManagedTags() const { return m_enableECSManagedTags; }
  inline bool EnableECSManagedTagsHasBeenSet() const { return m_enableECSManagedTagsHasBeenSet; }
  inline void SetEnableECSManagedTags(bool value) {
    m_enableECSManagedTagsHasBeenSet = true;
    m_enableECSManagedTags = value;
  }
  inline StartTaskRequest& WithEnableECSManagedTags(bool value) {
    SetEnableECSManagedTags(value);
    return *this;
  }
 
 
  inline bool GetEnableExecuteCommand() const { return m_enableExecuteCommand; }
  inline bool EnableExecuteCommandHasBeenSet() const { return m_enableExecuteCommandHasBeenSet; }
  inline void SetEnableExecuteCommand(bool value) {
    m_enableExecuteCommandHasBeenSet = true;
    m_enableExecuteCommand = value;
  }
  inline StartTaskRequest& WithEnableExecuteCommand(bool value) {
    SetEnableExecuteCommand(value);
    return *this;
  }
 
 
  inline const Aws::String& GetGroup() const { return m_group; }
  inline bool GroupHasBeenSet() const { return m_groupHasBeenSet; }
  template <typename GroupT = Aws::String>
  void SetGroup(GroupT&& value) {
    m_groupHasBeenSet = true;
    m_group = std::forward<GroupT>(value);
  }
  template <typename GroupT = Aws::String>
  StartTaskRequest& WithGroup(GroupT&& value) {
    SetGroup(std::forward<GroupT>(value));
    return *this;
  }
 
 
  inline const NetworkConfiguration& GetNetworkConfiguration() const { return m_networkConfiguration; }
  inline bool NetworkConfigurationHasBeenSet() const { return m_networkConfigurationHasBeenSet; }
  template <typename NetworkConfigurationT = NetworkConfiguration>
  void SetNetworkConfiguration(NetworkConfigurationT&& value) {
    m_networkConfigurationHasBeenSet = true;
    m_networkConfiguration = std::forward<NetworkConfigurationT>(value);
  }
  template <typename NetworkConfigurationT = NetworkConfiguration>
  StartTaskRequest& WithNetworkConfiguration(NetworkConfigurationT&& value) {
    SetNetworkConfiguration(std::forward<NetworkConfigurationT>(value));
    return *this;
  }
 
 
  inline const TaskOverride& GetOverrides() const { return m_overrides; }
  inline bool OverridesHasBeenSet() const { return m_overridesHasBeenSet; }
  template <typename OverridesT = TaskOverride>
  void SetOverrides(OverridesT&& value) {
    m_overridesHasBeenSet = true;
    m_overrides = std::forward<OverridesT>(value);
  }
  template <typename OverridesT = TaskOverride>
  StartTaskRequest& WithOverrides(OverridesT&& value) {
    SetOverrides(std::forward<OverridesT>(value));
    return *this;
  }
 
 
  inline PropagateTags GetPropagateTags() const { return m_propagateTags; }
  inline bool PropagateTagsHasBeenSet() const { return m_propagateTagsHasBeenSet; }
  inline void SetPropagateTags(PropagateTags value) {
    m_propagateTagsHasBeenSet = true;
    m_propagateTags = value;
  }
  inline StartTaskRequest& WithPropagateTags(PropagateTags value) {
    SetPropagateTags(value);
    return *this;
  }
 
 
  inline const Aws::String& GetReferenceId() const { return m_referenceId; }
  inline bool ReferenceIdHasBeenSet() const { return m_referenceIdHasBeenSet; }
  template <typename ReferenceIdT = Aws::String>
  void SetReferenceId(ReferenceIdT&& value) {
    m_referenceIdHasBeenSet = true;
    m_referenceId = std::forward<ReferenceIdT>(value);
  }
  template <typename ReferenceIdT = Aws::String>
  StartTaskRequest& WithReferenceId(ReferenceIdT&& value) {
    SetReferenceId(std::forward<ReferenceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStartedBy() const { return m_startedBy; }
  inline bool StartedByHasBeenSet() const { return m_startedByHasBeenSet; }
  template <typename StartedByT = Aws::String>
  void SetStartedBy(StartedByT&& value) {
    m_startedByHasBeenSet = true;
    m_startedBy = std::forward<StartedByT>(value);
  }
  template <typename StartedByT = Aws::String>
  StartTaskRequest& WithStartedBy(StartedByT&& value) {
    SetStartedBy(std::forward<StartedByT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  StartTaskRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  StartTaskRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTaskDefinition() const { return m_taskDefinition; }
  inline bool TaskDefinitionHasBeenSet() const { return m_taskDefinitionHasBeenSet; }
  template <typename TaskDefinitionT = Aws::String>
  void SetTaskDefinition(TaskDefinitionT&& value) {
    m_taskDefinitionHasBeenSet = true;
    m_taskDefinition = std::forward<TaskDefinitionT>(value);
  }
  template <typename TaskDefinitionT = Aws::String>
  StartTaskRequest& WithTaskDefinition(TaskDefinitionT&& value) {
    SetTaskDefinition(std::forward<TaskDefinitionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<TaskVolumeConfiguration>& GetVolumeConfigurations() const { return m_volumeConfigurations; }
  inline bool VolumeConfigurationsHasBeenSet() const { return m_volumeConfigurationsHasBeenSet; }
  template <typename VolumeConfigurationsT = Aws::Vector<TaskVolumeConfiguration>>
  void SetVolumeConfigurations(VolumeConfigurationsT&& value) {
    m_volumeConfigurationsHasBeenSet = true;
    m_volumeConfigurations = std::forward<VolumeConfigurationsT>(value);
  }
  template <typename VolumeConfigurationsT = Aws::Vector<TaskVolumeConfiguration>>
  StartTaskRequest& WithVolumeConfigurations(VolumeConfigurationsT&& value) {
    SetVolumeConfigurations(std::forward<VolumeConfigurationsT>(value));
    return *this;
  }
  template <typename VolumeConfigurationsT = TaskVolumeConfiguration>
  StartTaskRequest& AddVolumeConfigurations(VolumeConfigurationsT&& value) {
    m_volumeConfigurationsHasBeenSet = true;
    m_volumeConfigurations.emplace_back(std::forward<VolumeConfigurationsT>(value));
    return *this;
  }
 private:
  Aws::String m_cluster;
 
  Aws::Vector<Aws::String> m_containerInstances;
 
  bool m_enableECSManagedTags{false};
 
  bool m_enableExecuteCommand{false};
 
  Aws::String m_group;
 
  NetworkConfiguration m_networkConfiguration;
 
  TaskOverride m_overrides;
 
  PropagateTags m_propagateTags{PropagateTags::NOT_SET};
 
  Aws::String m_referenceId;
 
  Aws::String m_startedBy;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_taskDefinition;
 
  Aws::Vector<TaskVolumeConfiguration> m_volumeConfigurations;
  bool m_clusterHasBeenSet = false;
  bool m_containerInstancesHasBeenSet = false;
  bool m_enableECSManagedTagsHasBeenSet = false;
  bool m_enableExecuteCommandHasBeenSet = false;
  bool m_groupHasBeenSet = false;
  bool m_networkConfigurationHasBeenSet = false;
  bool m_overridesHasBeenSet = false;
  bool m_propagateTagsHasBeenSet = false;
  bool m_referenceIdHasBeenSet = false;
  bool m_startedByHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_taskDefinitionHasBeenSet = false;
  bool m_volumeConfigurationsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws