Task.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/ecs/model/Attachment.h>
#include <aws/ecs/model/Attribute.h>
#include <aws/ecs/model/Connectivity.h>
#include <aws/ecs/model/Container.h>
#include <aws/ecs/model/EphemeralStorage.h>
#include <aws/ecs/model/HealthStatus.h>
#include <aws/ecs/model/InferenceAccelerator.h>
#include <aws/ecs/model/LaunchType.h>
#include <aws/ecs/model/Tag.h>
#include <aws/ecs/model/TaskEphemeralStorage.h>
#include <aws/ecs/model/TaskOverride.h>
#include <aws/ecs/model/TaskStopCode.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ECS {
namespace Model {
 
class Task {
 public:
  AWS_ECS_API Task() = default;
  AWS_ECS_API Task(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API Task& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Attachment>& GetAttachments() const { return m_attachments; }
  inline bool AttachmentsHasBeenSet() const { return m_attachmentsHasBeenSet; }
  template <typename AttachmentsT = Aws::Vector<Attachment>>
  void SetAttachments(AttachmentsT&& value) {
    m_attachmentsHasBeenSet = true;
    m_attachments = std::forward<AttachmentsT>(value);
  }
  template <typename AttachmentsT = Aws::Vector<Attachment>>
  Task& WithAttachments(AttachmentsT&& value) {
    SetAttachments(std::forward<AttachmentsT>(value));
    return *this;
  }
  template <typename AttachmentsT = Attachment>
  Task& AddAttachments(AttachmentsT&& value) {
    m_attachmentsHasBeenSet = true;
    m_attachments.emplace_back(std::forward<AttachmentsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Attribute>& GetAttributes() const { return m_attributes; }
  inline bool AttributesHasBeenSet() const { return m_attributesHasBeenSet; }
  template <typename AttributesT = Aws::Vector<Attribute>>
  void SetAttributes(AttributesT&& value) {
    m_attributesHasBeenSet = true;
    m_attributes = std::forward<AttributesT>(value);
  }
  template <typename AttributesT = Aws::Vector<Attribute>>
  Task& WithAttributes(AttributesT&& value) {
    SetAttributes(std::forward<AttributesT>(value));
    return *this;
  }
  template <typename AttributesT = Attribute>
  Task& AddAttributes(AttributesT&& value) {
    m_attributesHasBeenSet = true;
    m_attributes.emplace_back(std::forward<AttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAvailabilityZone() const { return m_availabilityZone; }
  inline bool AvailabilityZoneHasBeenSet() const { return m_availabilityZoneHasBeenSet; }
  template <typename AvailabilityZoneT = Aws::String>
  void SetAvailabilityZone(AvailabilityZoneT&& value) {
    m_availabilityZoneHasBeenSet = true;
    m_availabilityZone = std::forward<AvailabilityZoneT>(value);
  }
  template <typename AvailabilityZoneT = Aws::String>
  Task& WithAvailabilityZone(AvailabilityZoneT&& value) {
    SetAvailabilityZone(std::forward<AvailabilityZoneT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCapacityProviderName() const { return m_capacityProviderName; }
  inline bool CapacityProviderNameHasBeenSet() const { return m_capacityProviderNameHasBeenSet; }
  template <typename CapacityProviderNameT = Aws::String>
  void SetCapacityProviderName(CapacityProviderNameT&& value) {
    m_capacityProviderNameHasBeenSet = true;
    m_capacityProviderName = std::forward<CapacityProviderNameT>(value);
  }
  template <typename CapacityProviderNameT = Aws::String>
  Task& WithCapacityProviderName(CapacityProviderNameT&& value) {
    SetCapacityProviderName(std::forward<CapacityProviderNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterArn() const { return m_clusterArn; }
  inline bool ClusterArnHasBeenSet() const { return m_clusterArnHasBeenSet; }
  template <typename ClusterArnT = Aws::String>
  void SetClusterArn(ClusterArnT&& value) {
    m_clusterArnHasBeenSet = true;
    m_clusterArn = std::forward<ClusterArnT>(value);
  }
  template <typename ClusterArnT = Aws::String>
  Task& WithClusterArn(ClusterArnT&& value) {
    SetClusterArn(std::forward<ClusterArnT>(value));
    return *this;
  }
 
 
  inline Connectivity GetConnectivity() const { return m_connectivity; }
  inline bool ConnectivityHasBeenSet() const { return m_connectivityHasBeenSet; }
  inline void SetConnectivity(Connectivity value) {
    m_connectivityHasBeenSet = true;
    m_connectivity = value;
  }
  inline Task& WithConnectivity(Connectivity value) {
    SetConnectivity(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetConnectivityAt() const { return m_connectivityAt; }
  inline bool ConnectivityAtHasBeenSet() const { return m_connectivityAtHasBeenSet; }
  template <typename ConnectivityAtT = Aws::Utils::DateTime>
  void SetConnectivityAt(ConnectivityAtT&& value) {
    m_connectivityAtHasBeenSet = true;
    m_connectivityAt = std::forward<ConnectivityAtT>(value);
  }
  template <typename ConnectivityAtT = Aws::Utils::DateTime>
  Task& WithConnectivityAt(ConnectivityAtT&& value) {
    SetConnectivityAt(std::forward<ConnectivityAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetContainerInstanceArn() const { return m_containerInstanceArn; }
  inline bool ContainerInstanceArnHasBeenSet() const { return m_containerInstanceArnHasBeenSet; }
  template <typename ContainerInstanceArnT = Aws::String>
  void SetContainerInstanceArn(ContainerInstanceArnT&& value) {
    m_containerInstanceArnHasBeenSet = true;
    m_containerInstanceArn = std::forward<ContainerInstanceArnT>(value);
  }
  template <typename ContainerInstanceArnT = Aws::String>
  Task& WithContainerInstanceArn(ContainerInstanceArnT&& value) {
    SetContainerInstanceArn(std::forward<ContainerInstanceArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Container>& GetContainers() const { return m_containers; }
  inline bool ContainersHasBeenSet() const { return m_containersHasBeenSet; }
  template <typename ContainersT = Aws::Vector<Container>>
  void SetContainers(ContainersT&& value) {
    m_containersHasBeenSet = true;
    m_containers = std::forward<ContainersT>(value);
  }
  template <typename ContainersT = Aws::Vector<Container>>
  Task& WithContainers(ContainersT&& value) {
    SetContainers(std::forward<ContainersT>(value));
    return *this;
  }
  template <typename ContainersT = Container>
  Task& AddContainers(ContainersT&& value) {
    m_containersHasBeenSet = true;
    m_containers.emplace_back(std::forward<ContainersT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCpu() const { return m_cpu; }
  inline bool CpuHasBeenSet() const { return m_cpuHasBeenSet; }
  template <typename CpuT = Aws::String>
  void SetCpu(CpuT&& value) {
    m_cpuHasBeenSet = true;
    m_cpu = std::forward<CpuT>(value);
  }
  template <typename CpuT = Aws::String>
  Task& WithCpu(CpuT&& value) {
    SetCpu(std::forward<CpuT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  Task& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDesiredStatus() const { return m_desiredStatus; }
  inline bool DesiredStatusHasBeenSet() const { return m_desiredStatusHasBeenSet; }
  template <typename DesiredStatusT = Aws::String>
  void SetDesiredStatus(DesiredStatusT&& value) {
    m_desiredStatusHasBeenSet = true;
    m_desiredStatus = std::forward<DesiredStatusT>(value);
  }
  template <typename DesiredStatusT = Aws::String>
  Task& WithDesiredStatus(DesiredStatusT&& value) {
    SetDesiredStatus(std::forward<DesiredStatusT>(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 Task& WithEnableExecuteCommand(bool value) {
    SetEnableExecuteCommand(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetExecutionStoppedAt() const { return m_executionStoppedAt; }
  inline bool ExecutionStoppedAtHasBeenSet() const { return m_executionStoppedAtHasBeenSet; }
  template <typename ExecutionStoppedAtT = Aws::Utils::DateTime>
  void SetExecutionStoppedAt(ExecutionStoppedAtT&& value) {
    m_executionStoppedAtHasBeenSet = true;
    m_executionStoppedAt = std::forward<ExecutionStoppedAtT>(value);
  }
  template <typename ExecutionStoppedAtT = Aws::Utils::DateTime>
  Task& WithExecutionStoppedAt(ExecutionStoppedAtT&& value) {
    SetExecutionStoppedAt(std::forward<ExecutionStoppedAtT>(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>
  Task& WithGroup(GroupT&& value) {
    SetGroup(std::forward<GroupT>(value));
    return *this;
  }
 
 
  inline HealthStatus GetHealthStatus() const { return m_healthStatus; }
  inline bool HealthStatusHasBeenSet() const { return m_healthStatusHasBeenSet; }
  inline void SetHealthStatus(HealthStatus value) {
    m_healthStatusHasBeenSet = true;
    m_healthStatus = value;
  }
  inline Task& WithHealthStatus(HealthStatus value) {
    SetHealthStatus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<InferenceAccelerator>& GetInferenceAccelerators() const { return m_inferenceAccelerators; }
  inline bool InferenceAcceleratorsHasBeenSet() const { return m_inferenceAcceleratorsHasBeenSet; }
  template <typename InferenceAcceleratorsT = Aws::Vector<InferenceAccelerator>>
  void SetInferenceAccelerators(InferenceAcceleratorsT&& value) {
    m_inferenceAcceleratorsHasBeenSet = true;
    m_inferenceAccelerators = std::forward<InferenceAcceleratorsT>(value);
  }
  template <typename InferenceAcceleratorsT = Aws::Vector<InferenceAccelerator>>
  Task& WithInferenceAccelerators(InferenceAcceleratorsT&& value) {
    SetInferenceAccelerators(std::forward<InferenceAcceleratorsT>(value));
    return *this;
  }
  template <typename InferenceAcceleratorsT = InferenceAccelerator>
  Task& AddInferenceAccelerators(InferenceAcceleratorsT&& value) {
    m_inferenceAcceleratorsHasBeenSet = true;
    m_inferenceAccelerators.emplace_back(std::forward<InferenceAcceleratorsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastStatus() const { return m_lastStatus; }
  inline bool LastStatusHasBeenSet() const { return m_lastStatusHasBeenSet; }
  template <typename LastStatusT = Aws::String>
  void SetLastStatus(LastStatusT&& value) {
    m_lastStatusHasBeenSet = true;
    m_lastStatus = std::forward<LastStatusT>(value);
  }
  template <typename LastStatusT = Aws::String>
  Task& WithLastStatus(LastStatusT&& value) {
    SetLastStatus(std::forward<LastStatusT>(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 Task& WithLaunchType(LaunchType value) {
    SetLaunchType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetMemory() const { return m_memory; }
  inline bool MemoryHasBeenSet() const { return m_memoryHasBeenSet; }
  template <typename MemoryT = Aws::String>
  void SetMemory(MemoryT&& value) {
    m_memoryHasBeenSet = true;
    m_memory = std::forward<MemoryT>(value);
  }
  template <typename MemoryT = Aws::String>
  Task& WithMemory(MemoryT&& value) {
    SetMemory(std::forward<MemoryT>(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>
  Task& WithOverrides(OverridesT&& value) {
    SetOverrides(std::forward<OverridesT>(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>
  Task& WithPlatformVersion(PlatformVersionT&& value) {
    SetPlatformVersion(std::forward<PlatformVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPlatformFamily() const { return m_platformFamily; }
  inline bool PlatformFamilyHasBeenSet() const { return m_platformFamilyHasBeenSet; }
  template <typename PlatformFamilyT = Aws::String>
  void SetPlatformFamily(PlatformFamilyT&& value) {
    m_platformFamilyHasBeenSet = true;
    m_platformFamily = std::forward<PlatformFamilyT>(value);
  }
  template <typename PlatformFamilyT = Aws::String>
  Task& WithPlatformFamily(PlatformFamilyT&& value) {
    SetPlatformFamily(std::forward<PlatformFamilyT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetPullStartedAt() const { return m_pullStartedAt; }
  inline bool PullStartedAtHasBeenSet() const { return m_pullStartedAtHasBeenSet; }
  template <typename PullStartedAtT = Aws::Utils::DateTime>
  void SetPullStartedAt(PullStartedAtT&& value) {
    m_pullStartedAtHasBeenSet = true;
    m_pullStartedAt = std::forward<PullStartedAtT>(value);
  }
  template <typename PullStartedAtT = Aws::Utils::DateTime>
  Task& WithPullStartedAt(PullStartedAtT&& value) {
    SetPullStartedAt(std::forward<PullStartedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetPullStoppedAt() const { return m_pullStoppedAt; }
  inline bool PullStoppedAtHasBeenSet() const { return m_pullStoppedAtHasBeenSet; }
  template <typename PullStoppedAtT = Aws::Utils::DateTime>
  void SetPullStoppedAt(PullStoppedAtT&& value) {
    m_pullStoppedAtHasBeenSet = true;
    m_pullStoppedAt = std::forward<PullStoppedAtT>(value);
  }
  template <typename PullStoppedAtT = Aws::Utils::DateTime>
  Task& WithPullStoppedAt(PullStoppedAtT&& value) {
    SetPullStoppedAt(std::forward<PullStoppedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStartedAt() const { return m_startedAt; }
  inline bool StartedAtHasBeenSet() const { return m_startedAtHasBeenSet; }
  template <typename StartedAtT = Aws::Utils::DateTime>
  void SetStartedAt(StartedAtT&& value) {
    m_startedAtHasBeenSet = true;
    m_startedAt = std::forward<StartedAtT>(value);
  }
  template <typename StartedAtT = Aws::Utils::DateTime>
  Task& WithStartedAt(StartedAtT&& value) {
    SetStartedAt(std::forward<StartedAtT>(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>
  Task& WithStartedBy(StartedByT&& value) {
    SetStartedBy(std::forward<StartedByT>(value));
    return *this;
  }
 
 
  inline TaskStopCode GetStopCode() const { return m_stopCode; }
  inline bool StopCodeHasBeenSet() const { return m_stopCodeHasBeenSet; }
  inline void SetStopCode(TaskStopCode value) {
    m_stopCodeHasBeenSet = true;
    m_stopCode = value;
  }
  inline Task& WithStopCode(TaskStopCode value) {
    SetStopCode(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStoppedAt() const { return m_stoppedAt; }
  inline bool StoppedAtHasBeenSet() const { return m_stoppedAtHasBeenSet; }
  template <typename StoppedAtT = Aws::Utils::DateTime>
  void SetStoppedAt(StoppedAtT&& value) {
    m_stoppedAtHasBeenSet = true;
    m_stoppedAt = std::forward<StoppedAtT>(value);
  }
  template <typename StoppedAtT = Aws::Utils::DateTime>
  Task& WithStoppedAt(StoppedAtT&& value) {
    SetStoppedAt(std::forward<StoppedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStoppedReason() const { return m_stoppedReason; }
  inline bool StoppedReasonHasBeenSet() const { return m_stoppedReasonHasBeenSet; }
  template <typename StoppedReasonT = Aws::String>
  void SetStoppedReason(StoppedReasonT&& value) {
    m_stoppedReasonHasBeenSet = true;
    m_stoppedReason = std::forward<StoppedReasonT>(value);
  }
  template <typename StoppedReasonT = Aws::String>
  Task& WithStoppedReason(StoppedReasonT&& value) {
    SetStoppedReason(std::forward<StoppedReasonT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStoppingAt() const { return m_stoppingAt; }
  inline bool StoppingAtHasBeenSet() const { return m_stoppingAtHasBeenSet; }
  template <typename StoppingAtT = Aws::Utils::DateTime>
  void SetStoppingAt(StoppingAtT&& value) {
    m_stoppingAtHasBeenSet = true;
    m_stoppingAt = std::forward<StoppingAtT>(value);
  }
  template <typename StoppingAtT = Aws::Utils::DateTime>
  Task& WithStoppingAt(StoppingAtT&& value) {
    SetStoppingAt(std::forward<StoppingAtT>(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>>
  Task& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  Task& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTaskArn() const { return m_taskArn; }
  inline bool TaskArnHasBeenSet() const { return m_taskArnHasBeenSet; }
  template <typename TaskArnT = Aws::String>
  void SetTaskArn(TaskArnT&& value) {
    m_taskArnHasBeenSet = true;
    m_taskArn = std::forward<TaskArnT>(value);
  }
  template <typename TaskArnT = Aws::String>
  Task& WithTaskArn(TaskArnT&& value) {
    SetTaskArn(std::forward<TaskArnT>(value));
    return *this;
  }
 
 
  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>
  Task& WithTaskDefinitionArn(TaskDefinitionArnT&& value) {
    SetTaskDefinitionArn(std::forward<TaskDefinitionArnT>(value));
    return *this;
  }
 
 
  inline long long GetVersion() const { return m_version; }
  inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
  inline void SetVersion(long long value) {
    m_versionHasBeenSet = true;
    m_version = value;
  }
  inline Task& WithVersion(long long value) {
    SetVersion(value);
    return *this;
  }
 
 
  inline const EphemeralStorage& GetEphemeralStorage() const { return m_ephemeralStorage; }
  inline bool EphemeralStorageHasBeenSet() const { return m_ephemeralStorageHasBeenSet; }
  template <typename EphemeralStorageT = EphemeralStorage>
  void SetEphemeralStorage(EphemeralStorageT&& value) {
    m_ephemeralStorageHasBeenSet = true;
    m_ephemeralStorage = std::forward<EphemeralStorageT>(value);
  }
  template <typename EphemeralStorageT = EphemeralStorage>
  Task& WithEphemeralStorage(EphemeralStorageT&& value) {
    SetEphemeralStorage(std::forward<EphemeralStorageT>(value));
    return *this;
  }
 
 
  inline const TaskEphemeralStorage& GetFargateEphemeralStorage() const { return m_fargateEphemeralStorage; }
  inline bool FargateEphemeralStorageHasBeenSet() const { return m_fargateEphemeralStorageHasBeenSet; }
  template <typename FargateEphemeralStorageT = TaskEphemeralStorage>
  void SetFargateEphemeralStorage(FargateEphemeralStorageT&& value) {
    m_fargateEphemeralStorageHasBeenSet = true;
    m_fargateEphemeralStorage = std::forward<FargateEphemeralStorageT>(value);
  }
  template <typename FargateEphemeralStorageT = TaskEphemeralStorage>
  Task& WithFargateEphemeralStorage(FargateEphemeralStorageT&& value) {
    SetFargateEphemeralStorage(std::forward<FargateEphemeralStorageT>(value));
    return *this;
  }
 private:
  Aws::Vector<Attachment> m_attachments;
 
  Aws::Vector<Attribute> m_attributes;
 
  Aws::String m_availabilityZone;
 
  Aws::String m_capacityProviderName;
 
  Aws::String m_clusterArn;
 
  Connectivity m_connectivity{Connectivity::NOT_SET};
 
  Aws::Utils::DateTime m_connectivityAt{};
 
  Aws::String m_containerInstanceArn;
 
  Aws::Vector<Container> m_containers;
 
  Aws::String m_cpu;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::String m_desiredStatus;
 
  bool m_enableExecuteCommand{false};
 
  Aws::Utils::DateTime m_executionStoppedAt{};
 
  Aws::String m_group;
 
  HealthStatus m_healthStatus{HealthStatus::NOT_SET};
 
  Aws::Vector<InferenceAccelerator> m_inferenceAccelerators;
 
  Aws::String m_lastStatus;
 
  LaunchType m_launchType{LaunchType::NOT_SET};
 
  Aws::String m_memory;
 
  TaskOverride m_overrides;
 
  Aws::String m_platformVersion;
 
  Aws::String m_platformFamily;
 
  Aws::Utils::DateTime m_pullStartedAt{};
 
  Aws::Utils::DateTime m_pullStoppedAt{};
 
  Aws::Utils::DateTime m_startedAt{};
 
  Aws::String m_startedBy;
 
  TaskStopCode m_stopCode{TaskStopCode::NOT_SET};
 
  Aws::Utils::DateTime m_stoppedAt{};
 
  Aws::String m_stoppedReason;
 
  Aws::Utils::DateTime m_stoppingAt{};
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_taskArn;
 
  Aws::String m_taskDefinitionArn;
 
  long long m_version{0};
 
  EphemeralStorage m_ephemeralStorage;
 
  TaskEphemeralStorage m_fargateEphemeralStorage;
  bool m_attachmentsHasBeenSet = false;
  bool m_attributesHasBeenSet = false;
  bool m_availabilityZoneHasBeenSet = false;
  bool m_capacityProviderNameHasBeenSet = false;
  bool m_clusterArnHasBeenSet = false;
  bool m_connectivityHasBeenSet = false;
  bool m_connectivityAtHasBeenSet = false;
  bool m_containerInstanceArnHasBeenSet = false;
  bool m_containersHasBeenSet = false;
  bool m_cpuHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_desiredStatusHasBeenSet = false;
  bool m_enableExecuteCommandHasBeenSet = false;
  bool m_executionStoppedAtHasBeenSet = false;
  bool m_groupHasBeenSet = false;
  bool m_healthStatusHasBeenSet = false;
  bool m_inferenceAcceleratorsHasBeenSet = false;
  bool m_lastStatusHasBeenSet = false;
  bool m_launchTypeHasBeenSet = false;
  bool m_memoryHasBeenSet = false;
  bool m_overridesHasBeenSet = false;
  bool m_platformVersionHasBeenSet = false;
  bool m_platformFamilyHasBeenSet = false;
  bool m_pullStartedAtHasBeenSet = false;
  bool m_pullStoppedAtHasBeenSet = false;
  bool m_startedAtHasBeenSet = false;
  bool m_startedByHasBeenSet = false;
  bool m_stopCodeHasBeenSet = false;
  bool m_stoppedAtHasBeenSet = false;
  bool m_stoppedReasonHasBeenSet = false;
  bool m_stoppingAtHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_taskArnHasBeenSet = false;
  bool m_taskDefinitionArnHasBeenSet = false;
  bool m_versionHasBeenSet = false;
  bool m_ephemeralStorageHasBeenSet = false;
  bool m_fargateEphemeralStorageHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws