PipeTargetEcsTaskParameters.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/pipes/Pipes_EXPORTS.h>
#include <aws/pipes/model/CapacityProviderStrategyItem.h>
#include <aws/pipes/model/EcsTaskOverride.h>
#include <aws/pipes/model/LaunchType.h>
#include <aws/pipes/model/NetworkConfiguration.h>
#include <aws/pipes/model/PlacementConstraint.h>
#include <aws/pipes/model/PlacementStrategy.h>
#include <aws/pipes/model/PropagateTags.h>
#include <aws/pipes/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Pipes {
namespace Model {
 
class PipeTargetEcsTaskParameters {
 public:
  AWS_PIPES_API PipeTargetEcsTaskParameters() = default;
  AWS_PIPES_API PipeTargetEcsTaskParameters(Aws::Utils::Json::JsonView jsonValue);
  AWS_PIPES_API PipeTargetEcsTaskParameters& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PIPES_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetTaskDefinitionArn() const { return m_taskDefinitionArn; }
  inline bool TaskDefinitionArnHasBeenSet() const { return m_taskDefinitionArnHasBeenSet; }
  template <typename TaskDefinitionArnT = Aws::String>
  void SetTaskDefinitionArn(TaskDefinitionArnT&& value) {
    m_taskDefinitionArnHasBeenSet = true;
    m_taskDefinitionArn = std::forward<TaskDefinitionArnT>(value);
  }
  template <typename TaskDefinitionArnT = Aws::String>
  PipeTargetEcsTaskParameters& WithTaskDefinitionArn(TaskDefinitionArnT&& value) {
    SetTaskDefinitionArn(std::forward<TaskDefinitionArnT>(value));
    return *this;
  }
 
 
  inline int GetTaskCount() const { return m_taskCount; }
  inline bool TaskCountHasBeenSet() const { return m_taskCountHasBeenSet; }
  inline void SetTaskCount(int value) {
    m_taskCountHasBeenSet = true;
    m_taskCount = value;
  }
  inline PipeTargetEcsTaskParameters& WithTaskCount(int value) {
    SetTaskCount(value);
    return *this;
  }
 
 
  inline LaunchType GetLaunchType() const { return m_launchType; }
  inline bool LaunchTypeHasBeenSet() const { return m_launchTypeHasBeenSet; }
  inline void SetLaunchType(LaunchType value) {
    m_launchTypeHasBeenSet = true;
    m_launchType = value;
  }
  inline PipeTargetEcsTaskParameters& WithLaunchType(LaunchType value) {
    SetLaunchType(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>
  PipeTargetEcsTaskParameters& WithNetworkConfiguration(NetworkConfigurationT&& value) {
    SetNetworkConfiguration(std::forward<NetworkConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPlatformVersion() const { return m_platformVersion; }
  inline bool PlatformVersionHasBeenSet() const { return m_platformVersionHasBeenSet; }
  template <typename PlatformVersionT = Aws::String>
  void SetPlatformVersion(PlatformVersionT&& value) {
    m_platformVersionHasBeenSet = true;
    m_platformVersion = std::forward<PlatformVersionT>(value);
  }
  template <typename PlatformVersionT = Aws::String>
  PipeTargetEcsTaskParameters& WithPlatformVersion(PlatformVersionT&& value) {
    SetPlatformVersion(std::forward<PlatformVersionT>(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>
  PipeTargetEcsTaskParameters& WithGroup(GroupT&& value) {
    SetGroup(std::forward<GroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CapacityProviderStrategyItem>& GetCapacityProviderStrategy() const { return m_capacityProviderStrategy; }
  inline bool CapacityProviderStrategyHasBeenSet() const { return m_capacityProviderStrategyHasBeenSet; }
  template <typename CapacityProviderStrategyT = Aws::Vector<CapacityProviderStrategyItem>>
  void SetCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    m_capacityProviderStrategyHasBeenSet = true;
    m_capacityProviderStrategy = std::forward<CapacityProviderStrategyT>(value);
  }
  template <typename CapacityProviderStrategyT = Aws::Vector<CapacityProviderStrategyItem>>
  PipeTargetEcsTaskParameters& WithCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    SetCapacityProviderStrategy(std::forward<CapacityProviderStrategyT>(value));
    return *this;
  }
  template <typename CapacityProviderStrategyT = CapacityProviderStrategyItem>
  PipeTargetEcsTaskParameters& AddCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    m_capacityProviderStrategyHasBeenSet = true;
    m_capacityProviderStrategy.emplace_back(std::forward<CapacityProviderStrategyT>(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 PipeTargetEcsTaskParameters& 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 PipeTargetEcsTaskParameters& WithEnableExecuteCommand(bool value) {
    SetEnableExecuteCommand(value);
    return *this;
  }
 
 
  inline const Aws::Vector<PlacementConstraint>& GetPlacementConstraints() const { return m_placementConstraints; }
  inline bool PlacementConstraintsHasBeenSet() const { return m_placementConstraintsHasBeenSet; }
  template <typename PlacementConstraintsT = Aws::Vector<PlacementConstraint>>
  void SetPlacementConstraints(PlacementConstraintsT&& value) {
    m_placementConstraintsHasBeenSet = true;
    m_placementConstraints = std::forward<PlacementConstraintsT>(value);
  }
  template <typename PlacementConstraintsT = Aws::Vector<PlacementConstraint>>
  PipeTargetEcsTaskParameters& WithPlacementConstraints(PlacementConstraintsT&& value) {
    SetPlacementConstraints(std::forward<PlacementConstraintsT>(value));
    return *this;
  }
  template <typename PlacementConstraintsT = PlacementConstraint>
  PipeTargetEcsTaskParameters& AddPlacementConstraints(PlacementConstraintsT&& value) {
    m_placementConstraintsHasBeenSet = true;
    m_placementConstraints.emplace_back(std::forward<PlacementConstraintsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<PlacementStrategy>& GetPlacementStrategy() const { return m_placementStrategy; }
  inline bool PlacementStrategyHasBeenSet() const { return m_placementStrategyHasBeenSet; }
  template <typename PlacementStrategyT = Aws::Vector<PlacementStrategy>>
  void SetPlacementStrategy(PlacementStrategyT&& value) {
    m_placementStrategyHasBeenSet = true;
    m_placementStrategy = std::forward<PlacementStrategyT>(value);
  }
  template <typename PlacementStrategyT = Aws::Vector<PlacementStrategy>>
  PipeTargetEcsTaskParameters& WithPlacementStrategy(PlacementStrategyT&& value) {
    SetPlacementStrategy(std::forward<PlacementStrategyT>(value));
    return *this;
  }
  template <typename PlacementStrategyT = PlacementStrategy>
  PipeTargetEcsTaskParameters& AddPlacementStrategy(PlacementStrategyT&& value) {
    m_placementStrategyHasBeenSet = true;
    m_placementStrategy.emplace_back(std::forward<PlacementStrategyT>(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 PipeTargetEcsTaskParameters& 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>
  PipeTargetEcsTaskParameters& WithReferenceId(ReferenceIdT&& value) {
    SetReferenceId(std::forward<ReferenceIdT>(value));
    return *this;
  }
 
 
  inline const EcsTaskOverride& GetOverrides() const { return m_overrides; }
  inline bool OverridesHasBeenSet() const { return m_overridesHasBeenSet; }
  template <typename OverridesT = EcsTaskOverride>
  void SetOverrides(OverridesT&& value) {
    m_overridesHasBeenSet = true;
    m_overrides = std::forward<OverridesT>(value);
  }
  template <typename OverridesT = EcsTaskOverride>
  PipeTargetEcsTaskParameters& WithOverrides(OverridesT&& value) {
    SetOverrides(std::forward<OverridesT>(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>>
  PipeTargetEcsTaskParameters& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  PipeTargetEcsTaskParameters& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 private:
  Aws::String m_taskDefinitionArn;
 
  int m_taskCount{0};
 
  LaunchType m_launchType{LaunchType::NOT_SET};
 
  NetworkConfiguration m_networkConfiguration;
 
  Aws::String m_platformVersion;
 
  Aws::String m_group;
 
  Aws::Vector<CapacityProviderStrategyItem> m_capacityProviderStrategy;
 
  bool m_enableECSManagedTags{false};
 
  bool m_enableExecuteCommand{false};
 
  Aws::Vector<PlacementConstraint> m_placementConstraints;
 
  Aws::Vector<PlacementStrategy> m_placementStrategy;
 
  PropagateTags m_propagateTags{PropagateTags::NOT_SET};
 
  Aws::String m_referenceId;
 
  EcsTaskOverride m_overrides;
 
  Aws::Vector<Tag> m_tags;
  bool m_taskDefinitionArnHasBeenSet = false;
  bool m_taskCountHasBeenSet = false;
  bool m_launchTypeHasBeenSet = false;
  bool m_networkConfigurationHasBeenSet = false;
  bool m_platformVersionHasBeenSet = false;
  bool m_groupHasBeenSet = false;
  bool m_capacityProviderStrategyHasBeenSet = false;
  bool m_enableECSManagedTagsHasBeenSet = false;
  bool m_enableExecuteCommandHasBeenSet = false;
  bool m_placementConstraintsHasBeenSet = false;
  bool m_placementStrategyHasBeenSet = false;
  bool m_propagateTagsHasBeenSet = false;
  bool m_referenceIdHasBeenSet = false;
  bool m_overridesHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Pipes
}  // namespace Aws