TaskSet.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/CapacityProviderStrategyItem.h>
#include <aws/ecs/model/DeploymentEphemeralStorage.h>
#include <aws/ecs/model/LaunchType.h>
#include <aws/ecs/model/LoadBalancer.h>
#include <aws/ecs/model/NetworkConfiguration.h>
#include <aws/ecs/model/Scale.h>
#include <aws/ecs/model/ServiceRegistry.h>
#include <aws/ecs/model/StabilityStatus.h>
#include <aws/ecs/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ECS {
namespace Model {
 
class TaskSet {
 public:
  AWS_ECS_API TaskSet() = default;
  AWS_ECS_API TaskSet(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API TaskSet& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  TaskSet& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTaskSetArn() const { return m_taskSetArn; }
  inline bool TaskSetArnHasBeenSet() const { return m_taskSetArnHasBeenSet; }
  template <typename TaskSetArnT = Aws::String>
  void SetTaskSetArn(TaskSetArnT&& value) {
    m_taskSetArnHasBeenSet = true;
    m_taskSetArn = std::forward<TaskSetArnT>(value);
  }
  template <typename TaskSetArnT = Aws::String>
  TaskSet& WithTaskSetArn(TaskSetArnT&& value) {
    SetTaskSetArn(std::forward<TaskSetArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServiceArn() const { return m_serviceArn; }
  inline bool ServiceArnHasBeenSet() const { return m_serviceArnHasBeenSet; }
  template <typename ServiceArnT = Aws::String>
  void SetServiceArn(ServiceArnT&& value) {
    m_serviceArnHasBeenSet = true;
    m_serviceArn = std::forward<ServiceArnT>(value);
  }
  template <typename ServiceArnT = Aws::String>
  TaskSet& WithServiceArn(ServiceArnT&& value) {
    SetServiceArn(std::forward<ServiceArnT>(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>
  TaskSet& WithClusterArn(ClusterArnT&& value) {
    SetClusterArn(std::forward<ClusterArnT>(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>
  TaskSet& WithStartedBy(StartedByT&& value) {
    SetStartedBy(std::forward<StartedByT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExternalId() const { return m_externalId; }
  inline bool ExternalIdHasBeenSet() const { return m_externalIdHasBeenSet; }
  template <typename ExternalIdT = Aws::String>
  void SetExternalId(ExternalIdT&& value) {
    m_externalIdHasBeenSet = true;
    m_externalId = std::forward<ExternalIdT>(value);
  }
  template <typename ExternalIdT = Aws::String>
  TaskSet& WithExternalId(ExternalIdT&& value) {
    SetExternalId(std::forward<ExternalIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  template <typename StatusT = Aws::String>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = Aws::String>
  TaskSet& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(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>
  TaskSet& WithTaskDefinition(TaskDefinitionT&& value) {
    SetTaskDefinition(std::forward<TaskDefinitionT>(value));
    return *this;
  }
 
 
  inline int GetComputedDesiredCount() const { return m_computedDesiredCount; }
  inline bool ComputedDesiredCountHasBeenSet() const { return m_computedDesiredCountHasBeenSet; }
  inline void SetComputedDesiredCount(int value) {
    m_computedDesiredCountHasBeenSet = true;
    m_computedDesiredCount = value;
  }
  inline TaskSet& WithComputedDesiredCount(int value) {
    SetComputedDesiredCount(value);
    return *this;
  }
 
 
  inline int GetPendingCount() const { return m_pendingCount; }
  inline bool PendingCountHasBeenSet() const { return m_pendingCountHasBeenSet; }
  inline void SetPendingCount(int value) {
    m_pendingCountHasBeenSet = true;
    m_pendingCount = value;
  }
  inline TaskSet& WithPendingCount(int value) {
    SetPendingCount(value);
    return *this;
  }
 
 
  inline int GetRunningCount() const { return m_runningCount; }
  inline bool RunningCountHasBeenSet() const { return m_runningCountHasBeenSet; }
  inline void SetRunningCount(int value) {
    m_runningCountHasBeenSet = true;
    m_runningCount = value;
  }
  inline TaskSet& WithRunningCount(int value) {
    SetRunningCount(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>
  TaskSet& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetUpdatedAt() const { return m_updatedAt; }
  inline bool UpdatedAtHasBeenSet() const { return m_updatedAtHasBeenSet; }
  template <typename UpdatedAtT = Aws::Utils::DateTime>
  void SetUpdatedAt(UpdatedAtT&& value) {
    m_updatedAtHasBeenSet = true;
    m_updatedAt = std::forward<UpdatedAtT>(value);
  }
  template <typename UpdatedAtT = Aws::Utils::DateTime>
  TaskSet& WithUpdatedAt(UpdatedAtT&& value) {
    SetUpdatedAt(std::forward<UpdatedAtT>(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 TaskSet& WithLaunchType(LaunchType value) {
    SetLaunchType(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>>
  TaskSet& WithCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    SetCapacityProviderStrategy(std::forward<CapacityProviderStrategyT>(value));
    return *this;
  }
  template <typename CapacityProviderStrategyT = CapacityProviderStrategyItem>
  TaskSet& AddCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    m_capacityProviderStrategyHasBeenSet = true;
    m_capacityProviderStrategy.emplace_back(std::forward<CapacityProviderStrategyT>(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>
  TaskSet& 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>
  TaskSet& WithPlatformFamily(PlatformFamilyT&& value) {
    SetPlatformFamily(std::forward<PlatformFamilyT>(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>
  TaskSet& WithNetworkConfiguration(NetworkConfigurationT&& value) {
    SetNetworkConfiguration(std::forward<NetworkConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LoadBalancer>& GetLoadBalancers() const { return m_loadBalancers; }
  inline bool LoadBalancersHasBeenSet() const { return m_loadBalancersHasBeenSet; }
  template <typename LoadBalancersT = Aws::Vector<LoadBalancer>>
  void SetLoadBalancers(LoadBalancersT&& value) {
    m_loadBalancersHasBeenSet = true;
    m_loadBalancers = std::forward<LoadBalancersT>(value);
  }
  template <typename LoadBalancersT = Aws::Vector<LoadBalancer>>
  TaskSet& WithLoadBalancers(LoadBalancersT&& value) {
    SetLoadBalancers(std::forward<LoadBalancersT>(value));
    return *this;
  }
  template <typename LoadBalancersT = LoadBalancer>
  TaskSet& AddLoadBalancers(LoadBalancersT&& value) {
    m_loadBalancersHasBeenSet = true;
    m_loadBalancers.emplace_back(std::forward<LoadBalancersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ServiceRegistry>& GetServiceRegistries() const { return m_serviceRegistries; }
  inline bool ServiceRegistriesHasBeenSet() const { return m_serviceRegistriesHasBeenSet; }
  template <typename ServiceRegistriesT = Aws::Vector<ServiceRegistry>>
  void SetServiceRegistries(ServiceRegistriesT&& value) {
    m_serviceRegistriesHasBeenSet = true;
    m_serviceRegistries = std::forward<ServiceRegistriesT>(value);
  }
  template <typename ServiceRegistriesT = Aws::Vector<ServiceRegistry>>
  TaskSet& WithServiceRegistries(ServiceRegistriesT&& value) {
    SetServiceRegistries(std::forward<ServiceRegistriesT>(value));
    return *this;
  }
  template <typename ServiceRegistriesT = ServiceRegistry>
  TaskSet& AddServiceRegistries(ServiceRegistriesT&& value) {
    m_serviceRegistriesHasBeenSet = true;
    m_serviceRegistries.emplace_back(std::forward<ServiceRegistriesT>(value));
    return *this;
  }
 
 
  inline const Scale& GetScale() const { return m_scale; }
  inline bool ScaleHasBeenSet() const { return m_scaleHasBeenSet; }
  template <typename ScaleT = Scale>
  void SetScale(ScaleT&& value) {
    m_scaleHasBeenSet = true;
    m_scale = std::forward<ScaleT>(value);
  }
  template <typename ScaleT = Scale>
  TaskSet& WithScale(ScaleT&& value) {
    SetScale(std::forward<ScaleT>(value));
    return *this;
  }
 
 
  inline StabilityStatus GetStabilityStatus() const { return m_stabilityStatus; }
  inline bool StabilityStatusHasBeenSet() const { return m_stabilityStatusHasBeenSet; }
  inline void SetStabilityStatus(StabilityStatus value) {
    m_stabilityStatusHasBeenSet = true;
    m_stabilityStatus = value;
  }
  inline TaskSet& WithStabilityStatus(StabilityStatus value) {
    SetStabilityStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStabilityStatusAt() const { return m_stabilityStatusAt; }
  inline bool StabilityStatusAtHasBeenSet() const { return m_stabilityStatusAtHasBeenSet; }
  template <typename StabilityStatusAtT = Aws::Utils::DateTime>
  void SetStabilityStatusAt(StabilityStatusAtT&& value) {
    m_stabilityStatusAtHasBeenSet = true;
    m_stabilityStatusAt = std::forward<StabilityStatusAtT>(value);
  }
  template <typename StabilityStatusAtT = Aws::Utils::DateTime>
  TaskSet& WithStabilityStatusAt(StabilityStatusAtT&& value) {
    SetStabilityStatusAt(std::forward<StabilityStatusAtT>(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>>
  TaskSet& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  TaskSet& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const DeploymentEphemeralStorage& GetFargateEphemeralStorage() const { return m_fargateEphemeralStorage; }
  inline bool FargateEphemeralStorageHasBeenSet() const { return m_fargateEphemeralStorageHasBeenSet; }
  template <typename FargateEphemeralStorageT = DeploymentEphemeralStorage>
  void SetFargateEphemeralStorage(FargateEphemeralStorageT&& value) {
    m_fargateEphemeralStorageHasBeenSet = true;
    m_fargateEphemeralStorage = std::forward<FargateEphemeralStorageT>(value);
  }
  template <typename FargateEphemeralStorageT = DeploymentEphemeralStorage>
  TaskSet& WithFargateEphemeralStorage(FargateEphemeralStorageT&& value) {
    SetFargateEphemeralStorage(std::forward<FargateEphemeralStorageT>(value));
    return *this;
  }
 private:
  Aws::String m_id;
 
  Aws::String m_taskSetArn;
 
  Aws::String m_serviceArn;
 
  Aws::String m_clusterArn;
 
  Aws::String m_startedBy;
 
  Aws::String m_externalId;
 
  Aws::String m_status;
 
  Aws::String m_taskDefinition;
 
  int m_computedDesiredCount{0};
 
  int m_pendingCount{0};
 
  int m_runningCount{0};
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::Utils::DateTime m_updatedAt{};
 
  LaunchType m_launchType{LaunchType::NOT_SET};
 
  Aws::Vector<CapacityProviderStrategyItem> m_capacityProviderStrategy;
 
  Aws::String m_platformVersion;
 
  Aws::String m_platformFamily;
 
  NetworkConfiguration m_networkConfiguration;
 
  Aws::Vector<LoadBalancer> m_loadBalancers;
 
  Aws::Vector<ServiceRegistry> m_serviceRegistries;
 
  Scale m_scale;
 
  StabilityStatus m_stabilityStatus{StabilityStatus::NOT_SET};
 
  Aws::Utils::DateTime m_stabilityStatusAt{};
 
  Aws::Vector<Tag> m_tags;
 
  DeploymentEphemeralStorage m_fargateEphemeralStorage;
  bool m_idHasBeenSet = false;
  bool m_taskSetArnHasBeenSet = false;
  bool m_serviceArnHasBeenSet = false;
  bool m_clusterArnHasBeenSet = false;
  bool m_startedByHasBeenSet = false;
  bool m_externalIdHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_taskDefinitionHasBeenSet = false;
  bool m_computedDesiredCountHasBeenSet = false;
  bool m_pendingCountHasBeenSet = false;
  bool m_runningCountHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_updatedAtHasBeenSet = false;
  bool m_launchTypeHasBeenSet = false;
  bool m_capacityProviderStrategyHasBeenSet = false;
  bool m_platformVersionHasBeenSet = false;
  bool m_platformFamilyHasBeenSet = false;
  bool m_networkConfigurationHasBeenSet = false;
  bool m_loadBalancersHasBeenSet = false;
  bool m_serviceRegistriesHasBeenSet = false;
  bool m_scaleHasBeenSet = false;
  bool m_stabilityStatusHasBeenSet = false;
  bool m_stabilityStatusAtHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_fargateEphemeralStorageHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws