ServiceRevision.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/ContainerImage.h>
#include <aws/ecs/model/DeploymentEphemeralStorage.h>
#include <aws/ecs/model/ECSManagedResources.h>
#include <aws/ecs/model/GatewayConnector.h>
#include <aws/ecs/model/LaunchType.h>
#include <aws/ecs/model/LoadBalancer.h>
#include <aws/ecs/model/MonitoringConfiguration.h>
#include <aws/ecs/model/NetworkConfiguration.h>
#include <aws/ecs/model/ResolvedConfiguration.h>
#include <aws/ecs/model/ServiceConnectConfiguration.h>
#include <aws/ecs/model/ServiceRegistry.h>
#include <aws/ecs/model/ServiceRevisionOverrides.h>
#include <aws/ecs/model/ServiceVolumeConfiguration.h>
#include <aws/ecs/model/VpcLatticeConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace ECS {
namespace Model {
 
class ServiceRevision {
 public:
  AWS_ECS_API ServiceRevision() = default;
  AWS_ECS_API ServiceRevision(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API ServiceRevision& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetServiceRevisionArn() const { return m_serviceRevisionArn; }
  inline bool ServiceRevisionArnHasBeenSet() const { return m_serviceRevisionArnHasBeenSet; }
  template <typename ServiceRevisionArnT = Aws::String>
  void SetServiceRevisionArn(ServiceRevisionArnT&& value) {
    m_serviceRevisionArnHasBeenSet = true;
    m_serviceRevisionArn = std::forward<ServiceRevisionArnT>(value);
  }
  template <typename ServiceRevisionArnT = Aws::String>
  ServiceRevision& WithServiceRevisionArn(ServiceRevisionArnT&& value) {
    SetServiceRevisionArn(std::forward<ServiceRevisionArnT>(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>
  ServiceRevision& 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>
  ServiceRevision& WithClusterArn(ClusterArnT&& value) {
    SetClusterArn(std::forward<ClusterArnT>(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>
  ServiceRevision& WithTaskDefinition(TaskDefinitionT&& value) {
    SetTaskDefinition(std::forward<TaskDefinitionT>(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>>
  ServiceRevision& WithCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    SetCapacityProviderStrategy(std::forward<CapacityProviderStrategyT>(value));
    return *this;
  }
  template <typename CapacityProviderStrategyT = CapacityProviderStrategyItem>
  ServiceRevision& AddCapacityProviderStrategy(CapacityProviderStrategyT&& value) {
    m_capacityProviderStrategyHasBeenSet = true;
    m_capacityProviderStrategy.emplace_back(std::forward<CapacityProviderStrategyT>(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 ServiceRevision& WithLaunchType(LaunchType value) {
    SetLaunchType(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>
  ServiceRevision& 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>
  ServiceRevision& WithPlatformFamily(PlatformFamilyT&& value) {
    SetPlatformFamily(std::forward<PlatformFamilyT>(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>>
  ServiceRevision& WithLoadBalancers(LoadBalancersT&& value) {
    SetLoadBalancers(std::forward<LoadBalancersT>(value));
    return *this;
  }
  template <typename LoadBalancersT = LoadBalancer>
  ServiceRevision& 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>>
  ServiceRevision& WithServiceRegistries(ServiceRegistriesT&& value) {
    SetServiceRegistries(std::forward<ServiceRegistriesT>(value));
    return *this;
  }
  template <typename ServiceRegistriesT = ServiceRegistry>
  ServiceRevision& AddServiceRegistries(ServiceRegistriesT&& value) {
    m_serviceRegistriesHasBeenSet = true;
    m_serviceRegistries.emplace_back(std::forward<ServiceRegistriesT>(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>
  ServiceRevision& WithNetworkConfiguration(NetworkConfigurationT&& value) {
    SetNetworkConfiguration(std::forward<NetworkConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ContainerImage>& GetContainerImages() const { return m_containerImages; }
  inline bool ContainerImagesHasBeenSet() const { return m_containerImagesHasBeenSet; }
  template <typename ContainerImagesT = Aws::Vector<ContainerImage>>
  void SetContainerImages(ContainerImagesT&& value) {
    m_containerImagesHasBeenSet = true;
    m_containerImages = std::forward<ContainerImagesT>(value);
  }
  template <typename ContainerImagesT = Aws::Vector<ContainerImage>>
  ServiceRevision& WithContainerImages(ContainerImagesT&& value) {
    SetContainerImages(std::forward<ContainerImagesT>(value));
    return *this;
  }
  template <typename ContainerImagesT = ContainerImage>
  ServiceRevision& AddContainerImages(ContainerImagesT&& value) {
    m_containerImagesHasBeenSet = true;
    m_containerImages.emplace_back(std::forward<ContainerImagesT>(value));
    return *this;
  }
 
 
  inline bool GetGuardDutyEnabled() const { return m_guardDutyEnabled; }
  inline bool GuardDutyEnabledHasBeenSet() const { return m_guardDutyEnabledHasBeenSet; }
  inline void SetGuardDutyEnabled(bool value) {
    m_guardDutyEnabledHasBeenSet = true;
    m_guardDutyEnabled = value;
  }
  inline ServiceRevision& WithGuardDutyEnabled(bool value) {
    SetGuardDutyEnabled(value);
    return *this;
  }
 
 
  inline const ServiceConnectConfiguration& GetServiceConnectConfiguration() const { return m_serviceConnectConfiguration; }
  inline bool ServiceConnectConfigurationHasBeenSet() const { return m_serviceConnectConfigurationHasBeenSet; }
  template <typename ServiceConnectConfigurationT = ServiceConnectConfiguration>
  void SetServiceConnectConfiguration(ServiceConnectConfigurationT&& value) {
    m_serviceConnectConfigurationHasBeenSet = true;
    m_serviceConnectConfiguration = std::forward<ServiceConnectConfigurationT>(value);
  }
  template <typename ServiceConnectConfigurationT = ServiceConnectConfiguration>
  ServiceRevision& WithServiceConnectConfiguration(ServiceConnectConfigurationT&& value) {
    SetServiceConnectConfiguration(std::forward<ServiceConnectConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ServiceVolumeConfiguration>& GetVolumeConfigurations() const { return m_volumeConfigurations; }
  inline bool VolumeConfigurationsHasBeenSet() const { return m_volumeConfigurationsHasBeenSet; }
  template <typename VolumeConfigurationsT = Aws::Vector<ServiceVolumeConfiguration>>
  void SetVolumeConfigurations(VolumeConfigurationsT&& value) {
    m_volumeConfigurationsHasBeenSet = true;
    m_volumeConfigurations = std::forward<VolumeConfigurationsT>(value);
  }
  template <typename VolumeConfigurationsT = Aws::Vector<ServiceVolumeConfiguration>>
  ServiceRevision& WithVolumeConfigurations(VolumeConfigurationsT&& value) {
    SetVolumeConfigurations(std::forward<VolumeConfigurationsT>(value));
    return *this;
  }
  template <typename VolumeConfigurationsT = ServiceVolumeConfiguration>
  ServiceRevision& AddVolumeConfigurations(VolumeConfigurationsT&& value) {
    m_volumeConfigurationsHasBeenSet = true;
    m_volumeConfigurations.emplace_back(std::forward<VolumeConfigurationsT>(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>
  ServiceRevision& WithFargateEphemeralStorage(FargateEphemeralStorageT&& value) {
    SetFargateEphemeralStorage(std::forward<FargateEphemeralStorageT>(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>
  ServiceRevision& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<VpcLatticeConfiguration>& GetVpcLatticeConfigurations() const { return m_vpcLatticeConfigurations; }
  inline bool VpcLatticeConfigurationsHasBeenSet() const { return m_vpcLatticeConfigurationsHasBeenSet; }
  template <typename VpcLatticeConfigurationsT = Aws::Vector<VpcLatticeConfiguration>>
  void SetVpcLatticeConfigurations(VpcLatticeConfigurationsT&& value) {
    m_vpcLatticeConfigurationsHasBeenSet = true;
    m_vpcLatticeConfigurations = std::forward<VpcLatticeConfigurationsT>(value);
  }
  template <typename VpcLatticeConfigurationsT = Aws::Vector<VpcLatticeConfiguration>>
  ServiceRevision& WithVpcLatticeConfigurations(VpcLatticeConfigurationsT&& value) {
    SetVpcLatticeConfigurations(std::forward<VpcLatticeConfigurationsT>(value));
    return *this;
  }
  template <typename VpcLatticeConfigurationsT = VpcLatticeConfiguration>
  ServiceRevision& AddVpcLatticeConfigurations(VpcLatticeConfigurationsT&& value) {
    m_vpcLatticeConfigurationsHasBeenSet = true;
    m_vpcLatticeConfigurations.emplace_back(std::forward<VpcLatticeConfigurationsT>(value));
    return *this;
  }
 
 
  inline const ResolvedConfiguration& GetResolvedConfiguration() const { return m_resolvedConfiguration; }
  inline bool ResolvedConfigurationHasBeenSet() const { return m_resolvedConfigurationHasBeenSet; }
  template <typename ResolvedConfigurationT = ResolvedConfiguration>
  void SetResolvedConfiguration(ResolvedConfigurationT&& value) {
    m_resolvedConfigurationHasBeenSet = true;
    m_resolvedConfiguration = std::forward<ResolvedConfigurationT>(value);
  }
  template <typename ResolvedConfigurationT = ResolvedConfiguration>
  ServiceRevision& WithResolvedConfiguration(ResolvedConfigurationT&& value) {
    SetResolvedConfiguration(std::forward<ResolvedConfigurationT>(value));
    return *this;
  }
 
 
  inline const ECSManagedResources& GetEcsManagedResources() const { return m_ecsManagedResources; }
  inline bool EcsManagedResourcesHasBeenSet() const { return m_ecsManagedResourcesHasBeenSet; }
  template <typename EcsManagedResourcesT = ECSManagedResources>
  void SetEcsManagedResources(EcsManagedResourcesT&& value) {
    m_ecsManagedResourcesHasBeenSet = true;
    m_ecsManagedResources = std::forward<EcsManagedResourcesT>(value);
  }
  template <typename EcsManagedResourcesT = ECSManagedResources>
  ServiceRevision& WithEcsManagedResources(EcsManagedResourcesT&& value) {
    SetEcsManagedResources(std::forward<EcsManagedResourcesT>(value));
    return *this;
  }
 
 
  inline const ServiceRevisionOverrides& GetOverrides() const { return m_overrides; }
  inline bool OverridesHasBeenSet() const { return m_overridesHasBeenSet; }
  template <typename OverridesT = ServiceRevisionOverrides>
  void SetOverrides(OverridesT&& value) {
    m_overridesHasBeenSet = true;
    m_overrides = std::forward<OverridesT>(value);
  }
  template <typename OverridesT = ServiceRevisionOverrides>
  ServiceRevision& WithOverrides(OverridesT&& value) {
    SetOverrides(std::forward<OverridesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<GatewayConnector>& GetGatewayConnectors() const { return m_gatewayConnectors; }
  inline bool GatewayConnectorsHasBeenSet() const { return m_gatewayConnectorsHasBeenSet; }
  template <typename GatewayConnectorsT = Aws::Vector<GatewayConnector>>
  void SetGatewayConnectors(GatewayConnectorsT&& value) {
    m_gatewayConnectorsHasBeenSet = true;
    m_gatewayConnectors = std::forward<GatewayConnectorsT>(value);
  }
  template <typename GatewayConnectorsT = Aws::Vector<GatewayConnector>>
  ServiceRevision& WithGatewayConnectors(GatewayConnectorsT&& value) {
    SetGatewayConnectors(std::forward<GatewayConnectorsT>(value));
    return *this;
  }
  template <typename GatewayConnectorsT = GatewayConnector>
  ServiceRevision& AddGatewayConnectors(GatewayConnectorsT&& value) {
    m_gatewayConnectorsHasBeenSet = true;
    m_gatewayConnectors.emplace_back(std::forward<GatewayConnectorsT>(value));
    return *this;
  }
 
 
  inline const MonitoringConfiguration& GetMonitoring() const { return m_monitoring; }
  inline bool MonitoringHasBeenSet() const { return m_monitoringHasBeenSet; }
  template <typename MonitoringT = MonitoringConfiguration>
  void SetMonitoring(MonitoringT&& value) {
    m_monitoringHasBeenSet = true;
    m_monitoring = std::forward<MonitoringT>(value);
  }
  template <typename MonitoringT = MonitoringConfiguration>
  ServiceRevision& WithMonitoring(MonitoringT&& value) {
    SetMonitoring(std::forward<MonitoringT>(value));
    return *this;
  }
 private:
  Aws::String m_serviceRevisionArn;
 
  Aws::String m_serviceArn;
 
  Aws::String m_clusterArn;
 
  Aws::String m_taskDefinition;
 
  Aws::Vector<CapacityProviderStrategyItem> m_capacityProviderStrategy;
 
  LaunchType m_launchType{LaunchType::NOT_SET};
 
  Aws::String m_platformVersion;
 
  Aws::String m_platformFamily;
 
  Aws::Vector<LoadBalancer> m_loadBalancers;
 
  Aws::Vector<ServiceRegistry> m_serviceRegistries;
 
  NetworkConfiguration m_networkConfiguration;
 
  Aws::Vector<ContainerImage> m_containerImages;
 
  bool m_guardDutyEnabled{false};
 
  ServiceConnectConfiguration m_serviceConnectConfiguration;
 
  Aws::Vector<ServiceVolumeConfiguration> m_volumeConfigurations;
 
  DeploymentEphemeralStorage m_fargateEphemeralStorage;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::Vector<VpcLatticeConfiguration> m_vpcLatticeConfigurations;
 
  ResolvedConfiguration m_resolvedConfiguration;
 
  ECSManagedResources m_ecsManagedResources;
 
  ServiceRevisionOverrides m_overrides;
 
  Aws::Vector<GatewayConnector> m_gatewayConnectors;
 
  MonitoringConfiguration m_monitoring;
  bool m_serviceRevisionArnHasBeenSet = false;
  bool m_serviceArnHasBeenSet = false;
  bool m_clusterArnHasBeenSet = false;
  bool m_taskDefinitionHasBeenSet = false;
  bool m_capacityProviderStrategyHasBeenSet = false;
  bool m_launchTypeHasBeenSet = false;
  bool m_platformVersionHasBeenSet = false;
  bool m_platformFamilyHasBeenSet = false;
  bool m_loadBalancersHasBeenSet = false;
  bool m_serviceRegistriesHasBeenSet = false;
  bool m_networkConfigurationHasBeenSet = false;
  bool m_containerImagesHasBeenSet = false;
  bool m_guardDutyEnabledHasBeenSet = false;
  bool m_serviceConnectConfigurationHasBeenSet = false;
  bool m_volumeConfigurationsHasBeenSet = false;
  bool m_fargateEphemeralStorageHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_vpcLatticeConfigurationsHasBeenSet = false;
  bool m_resolvedConfigurationHasBeenSet = false;
  bool m_ecsManagedResourcesHasBeenSet = false;
  bool m_overridesHasBeenSet = false;
  bool m_gatewayConnectorsHasBeenSet = false;
  bool m_monitoringHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws