ContainerDefinition.h

 
#pragma once
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ecs/model/RepositoryCredentials.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/model/ContainerRestartPolicy.h>
#include <aws/ecs/model/LinuxParameters.h>
#include <aws/ecs/model/VersionConsistency.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/ecs/model/LogConfiguration.h>
#include <aws/ecs/model/HealthCheck.h>
#include <aws/ecs/model/FirelensConfiguration.h>
#include <aws/ecs/model/PortMapping.h>
#include <aws/ecs/model/KeyValuePair.h>
#include <aws/ecs/model/EnvironmentFile.h>
#include <aws/ecs/model/MountPoint.h>
#include <aws/ecs/model/VolumeFrom.h>
#include <aws/ecs/model/Secret.h>
#include <aws/ecs/model/ContainerDependency.h>
#include <aws/ecs/model/HostEntry.h>
#include <aws/ecs/model/Ulimit.h>
#include <aws/ecs/model/SystemControl.h>
#include <aws/ecs/model/ResourceRequirement.h>
#include <utility>
 
namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace ECS
{
namespace Model
{
 
  class ContainerDefinition
  {
  public:
    AWS_ECS_API ContainerDefinition() = default;
    AWS_ECS_API ContainerDefinition(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API ContainerDefinition& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    inline const Aws::String& GetName() const { return m_name; }
    inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
    template<typename NameT = Aws::String>
    void SetName(NameT&& value) { m_nameHasBeenSet = true; m_name = std::forward<NameT>(value); }
    template<typename NameT = Aws::String>
    ContainerDefinition& WithName(NameT&& value) { SetName(std::forward<NameT>(value)); return *this;}
 
 
    inline const Aws::String& GetImage() const { return m_image; }
    inline bool ImageHasBeenSet() const { return m_imageHasBeenSet; }
    template<typename ImageT = Aws::String>
    void SetImage(ImageT&& value) { m_imageHasBeenSet = true; m_image = std::forward<ImageT>(value); }
    template<typename ImageT = Aws::String>
    ContainerDefinition& WithImage(ImageT&& value) { SetImage(std::forward<ImageT>(value)); return *this;}
 
 
    inline const RepositoryCredentials& GetRepositoryCredentials() const { return m_repositoryCredentials; }
    inline bool RepositoryCredentialsHasBeenSet() const { return m_repositoryCredentialsHasBeenSet; }
    template<typename RepositoryCredentialsT = RepositoryCredentials>
    void SetRepositoryCredentials(RepositoryCredentialsT&& value) { m_repositoryCredentialsHasBeenSet = true; m_repositoryCredentials = std::forward<RepositoryCredentialsT>(value); }
    template<typename RepositoryCredentialsT = RepositoryCredentials>
    ContainerDefinition& WithRepositoryCredentials(RepositoryCredentialsT&& value) { SetRepositoryCredentials(std::forward<RepositoryCredentialsT>(value)); return *this;}
 
 
    inline int GetCpu() const { return m_cpu; }
    inline bool CpuHasBeenSet() const { return m_cpuHasBeenSet; }
    inline void SetCpu(int value) { m_cpuHasBeenSet = true; m_cpu = value; }
    inline ContainerDefinition& WithCpu(int value) { SetCpu(value); return *this;}
 
 
    inline int GetMemory() const { return m_memory; }
    inline bool MemoryHasBeenSet() const { return m_memoryHasBeenSet; }
    inline void SetMemory(int value) { m_memoryHasBeenSet = true; m_memory = value; }
    inline ContainerDefinition& WithMemory(int value) { SetMemory(value); return *this;}
 
 
    inline int GetMemoryReservation() const { return m_memoryReservation; }
    inline bool MemoryReservationHasBeenSet() const { return m_memoryReservationHasBeenSet; }
    inline void SetMemoryReservation(int value) { m_memoryReservationHasBeenSet = true; m_memoryReservation = value; }
    inline ContainerDefinition& WithMemoryReservation(int value) { SetMemoryReservation(value); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetLinks() const { return m_links; }
    inline bool LinksHasBeenSet() const { return m_linksHasBeenSet; }
    template<typename LinksT = Aws::Vector<Aws::String>>
    void SetLinks(LinksT&& value) { m_linksHasBeenSet = true; m_links = std::forward<LinksT>(value); }
    template<typename LinksT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithLinks(LinksT&& value) { SetLinks(std::forward<LinksT>(value)); return *this;}
    template<typename LinksT = Aws::String>
    ContainerDefinition& AddLinks(LinksT&& value) { m_linksHasBeenSet = true; m_links.emplace_back(std::forward<LinksT>(value)); return *this; }
 
 
    inline const Aws::Vector<PortMapping>& GetPortMappings() const { return m_portMappings; }
    inline bool PortMappingsHasBeenSet() const { return m_portMappingsHasBeenSet; }
    template<typename PortMappingsT = Aws::Vector<PortMapping>>
    void SetPortMappings(PortMappingsT&& value) { m_portMappingsHasBeenSet = true; m_portMappings = std::forward<PortMappingsT>(value); }
    template<typename PortMappingsT = Aws::Vector<PortMapping>>
    ContainerDefinition& WithPortMappings(PortMappingsT&& value) { SetPortMappings(std::forward<PortMappingsT>(value)); return *this;}
    template<typename PortMappingsT = PortMapping>
    ContainerDefinition& AddPortMappings(PortMappingsT&& value) { m_portMappingsHasBeenSet = true; m_portMappings.emplace_back(std::forward<PortMappingsT>(value)); return *this; }
 
 
    inline bool GetEssential() const { return m_essential; }
    inline bool EssentialHasBeenSet() const { return m_essentialHasBeenSet; }
    inline void SetEssential(bool value) { m_essentialHasBeenSet = true; m_essential = value; }
    inline ContainerDefinition& WithEssential(bool value) { SetEssential(value); return *this;}
 
 
    inline const ContainerRestartPolicy& GetRestartPolicy() const { return m_restartPolicy; }
    inline bool RestartPolicyHasBeenSet() const { return m_restartPolicyHasBeenSet; }
    template<typename RestartPolicyT = ContainerRestartPolicy>
    void SetRestartPolicy(RestartPolicyT&& value) { m_restartPolicyHasBeenSet = true; m_restartPolicy = std::forward<RestartPolicyT>(value); }
    template<typename RestartPolicyT = ContainerRestartPolicy>
    ContainerDefinition& WithRestartPolicy(RestartPolicyT&& value) { SetRestartPolicy(std::forward<RestartPolicyT>(value)); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetEntryPoint() const { return m_entryPoint; }
    inline bool EntryPointHasBeenSet() const { return m_entryPointHasBeenSet; }
    template<typename EntryPointT = Aws::Vector<Aws::String>>
    void SetEntryPoint(EntryPointT&& value) { m_entryPointHasBeenSet = true; m_entryPoint = std::forward<EntryPointT>(value); }
    template<typename EntryPointT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithEntryPoint(EntryPointT&& value) { SetEntryPoint(std::forward<EntryPointT>(value)); return *this;}
    template<typename EntryPointT = Aws::String>
    ContainerDefinition& AddEntryPoint(EntryPointT&& value) { m_entryPointHasBeenSet = true; m_entryPoint.emplace_back(std::forward<EntryPointT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetCommand() const { return m_command; }
    inline bool CommandHasBeenSet() const { return m_commandHasBeenSet; }
    template<typename CommandT = Aws::Vector<Aws::String>>
    void SetCommand(CommandT&& value) { m_commandHasBeenSet = true; m_command = std::forward<CommandT>(value); }
    template<typename CommandT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithCommand(CommandT&& value) { SetCommand(std::forward<CommandT>(value)); return *this;}
    template<typename CommandT = Aws::String>
    ContainerDefinition& AddCommand(CommandT&& value) { m_commandHasBeenSet = true; m_command.emplace_back(std::forward<CommandT>(value)); return *this; }
 
 
    inline const Aws::Vector<KeyValuePair>& GetEnvironment() const { return m_environment; }
    inline bool EnvironmentHasBeenSet() const { return m_environmentHasBeenSet; }
    template<typename EnvironmentT = Aws::Vector<KeyValuePair>>
    void SetEnvironment(EnvironmentT&& value) { m_environmentHasBeenSet = true; m_environment = std::forward<EnvironmentT>(value); }
    template<typename EnvironmentT = Aws::Vector<KeyValuePair>>
    ContainerDefinition& WithEnvironment(EnvironmentT&& value) { SetEnvironment(std::forward<EnvironmentT>(value)); return *this;}
    template<typename EnvironmentT = KeyValuePair>
    ContainerDefinition& AddEnvironment(EnvironmentT&& value) { m_environmentHasBeenSet = true; m_environment.emplace_back(std::forward<EnvironmentT>(value)); return *this; }
 
 
    inline const Aws::Vector<EnvironmentFile>& GetEnvironmentFiles() const { return m_environmentFiles; }
    inline bool EnvironmentFilesHasBeenSet() const { return m_environmentFilesHasBeenSet; }
    template<typename EnvironmentFilesT = Aws::Vector<EnvironmentFile>>
    void SetEnvironmentFiles(EnvironmentFilesT&& value) { m_environmentFilesHasBeenSet = true; m_environmentFiles = std::forward<EnvironmentFilesT>(value); }
    template<typename EnvironmentFilesT = Aws::Vector<EnvironmentFile>>
    ContainerDefinition& WithEnvironmentFiles(EnvironmentFilesT&& value) { SetEnvironmentFiles(std::forward<EnvironmentFilesT>(value)); return *this;}
    template<typename EnvironmentFilesT = EnvironmentFile>
    ContainerDefinition& AddEnvironmentFiles(EnvironmentFilesT&& value) { m_environmentFilesHasBeenSet = true; m_environmentFiles.emplace_back(std::forward<EnvironmentFilesT>(value)); return *this; }
 
 
    inline const Aws::Vector<MountPoint>& GetMountPoints() const { return m_mountPoints; }
    inline bool MountPointsHasBeenSet() const { return m_mountPointsHasBeenSet; }
    template<typename MountPointsT = Aws::Vector<MountPoint>>
    void SetMountPoints(MountPointsT&& value) { m_mountPointsHasBeenSet = true; m_mountPoints = std::forward<MountPointsT>(value); }
    template<typename MountPointsT = Aws::Vector<MountPoint>>
    ContainerDefinition& WithMountPoints(MountPointsT&& value) { SetMountPoints(std::forward<MountPointsT>(value)); return *this;}
    template<typename MountPointsT = MountPoint>
    ContainerDefinition& AddMountPoints(MountPointsT&& value) { m_mountPointsHasBeenSet = true; m_mountPoints.emplace_back(std::forward<MountPointsT>(value)); return *this; }
 
 
    inline const Aws::Vector<VolumeFrom>& GetVolumesFrom() const { return m_volumesFrom; }
    inline bool VolumesFromHasBeenSet() const { return m_volumesFromHasBeenSet; }
    template<typename VolumesFromT = Aws::Vector<VolumeFrom>>
    void SetVolumesFrom(VolumesFromT&& value) { m_volumesFromHasBeenSet = true; m_volumesFrom = std::forward<VolumesFromT>(value); }
    template<typename VolumesFromT = Aws::Vector<VolumeFrom>>
    ContainerDefinition& WithVolumesFrom(VolumesFromT&& value) { SetVolumesFrom(std::forward<VolumesFromT>(value)); return *this;}
    template<typename VolumesFromT = VolumeFrom>
    ContainerDefinition& AddVolumesFrom(VolumesFromT&& value) { m_volumesFromHasBeenSet = true; m_volumesFrom.emplace_back(std::forward<VolumesFromT>(value)); return *this; }
 
 
    inline const LinuxParameters& GetLinuxParameters() const { return m_linuxParameters; }
    inline bool LinuxParametersHasBeenSet() const { return m_linuxParametersHasBeenSet; }
    template<typename LinuxParametersT = LinuxParameters>
    void SetLinuxParameters(LinuxParametersT&& value) { m_linuxParametersHasBeenSet = true; m_linuxParameters = std::forward<LinuxParametersT>(value); }
    template<typename LinuxParametersT = LinuxParameters>
    ContainerDefinition& WithLinuxParameters(LinuxParametersT&& value) { SetLinuxParameters(std::forward<LinuxParametersT>(value)); return *this;}
 
 
    inline const Aws::Vector<Secret>& GetSecrets() const { return m_secrets; }
    inline bool SecretsHasBeenSet() const { return m_secretsHasBeenSet; }
    template<typename SecretsT = Aws::Vector<Secret>>
    void SetSecrets(SecretsT&& value) { m_secretsHasBeenSet = true; m_secrets = std::forward<SecretsT>(value); }
    template<typename SecretsT = Aws::Vector<Secret>>
    ContainerDefinition& WithSecrets(SecretsT&& value) { SetSecrets(std::forward<SecretsT>(value)); return *this;}
    template<typename SecretsT = Secret>
    ContainerDefinition& AddSecrets(SecretsT&& value) { m_secretsHasBeenSet = true; m_secrets.emplace_back(std::forward<SecretsT>(value)); return *this; }
 
 
    inline const Aws::Vector<ContainerDependency>& GetDependsOn() const { return m_dependsOn; }
    inline bool DependsOnHasBeenSet() const { return m_dependsOnHasBeenSet; }
    template<typename DependsOnT = Aws::Vector<ContainerDependency>>
    void SetDependsOn(DependsOnT&& value) { m_dependsOnHasBeenSet = true; m_dependsOn = std::forward<DependsOnT>(value); }
    template<typename DependsOnT = Aws::Vector<ContainerDependency>>
    ContainerDefinition& WithDependsOn(DependsOnT&& value) { SetDependsOn(std::forward<DependsOnT>(value)); return *this;}
    template<typename DependsOnT = ContainerDependency>
    ContainerDefinition& AddDependsOn(DependsOnT&& value) { m_dependsOnHasBeenSet = true; m_dependsOn.emplace_back(std::forward<DependsOnT>(value)); return *this; }
 
 
    inline int GetStartTimeout() const { return m_startTimeout; }
    inline bool StartTimeoutHasBeenSet() const { return m_startTimeoutHasBeenSet; }
    inline void SetStartTimeout(int value) { m_startTimeoutHasBeenSet = true; m_startTimeout = value; }
    inline ContainerDefinition& WithStartTimeout(int value) { SetStartTimeout(value); return *this;}
 
 
    inline int GetStopTimeout() const { return m_stopTimeout; }
    inline bool StopTimeoutHasBeenSet() const { return m_stopTimeoutHasBeenSet; }
    inline void SetStopTimeout(int value) { m_stopTimeoutHasBeenSet = true; m_stopTimeout = value; }
    inline ContainerDefinition& WithStopTimeout(int value) { SetStopTimeout(value); return *this;}
 
 
    inline VersionConsistency GetVersionConsistency() const { return m_versionConsistency; }
    inline bool VersionConsistencyHasBeenSet() const { return m_versionConsistencyHasBeenSet; }
    inline void SetVersionConsistency(VersionConsistency value) { m_versionConsistencyHasBeenSet = true; m_versionConsistency = value; }
    inline ContainerDefinition& WithVersionConsistency(VersionConsistency value) { SetVersionConsistency(value); return *this;}
 
 
    inline const Aws::String& GetHostname() const { return m_hostname; }
    inline bool HostnameHasBeenSet() const { return m_hostnameHasBeenSet; }
    template<typename HostnameT = Aws::String>
    void SetHostname(HostnameT&& value) { m_hostnameHasBeenSet = true; m_hostname = std::forward<HostnameT>(value); }
    template<typename HostnameT = Aws::String>
    ContainerDefinition& WithHostname(HostnameT&& value) { SetHostname(std::forward<HostnameT>(value)); return *this;}
 
 
    inline const Aws::String& GetUser() const { return m_user; }
    inline bool UserHasBeenSet() const { return m_userHasBeenSet; }
    template<typename UserT = Aws::String>
    void SetUser(UserT&& value) { m_userHasBeenSet = true; m_user = std::forward<UserT>(value); }
    template<typename UserT = Aws::String>
    ContainerDefinition& WithUser(UserT&& value) { SetUser(std::forward<UserT>(value)); return *this;}
 
 
    inline const Aws::String& GetWorkingDirectory() const { return m_workingDirectory; }
    inline bool WorkingDirectoryHasBeenSet() const { return m_workingDirectoryHasBeenSet; }
    template<typename WorkingDirectoryT = Aws::String>
    void SetWorkingDirectory(WorkingDirectoryT&& value) { m_workingDirectoryHasBeenSet = true; m_workingDirectory = std::forward<WorkingDirectoryT>(value); }
    template<typename WorkingDirectoryT = Aws::String>
    ContainerDefinition& WithWorkingDirectory(WorkingDirectoryT&& value) { SetWorkingDirectory(std::forward<WorkingDirectoryT>(value)); return *this;}
 
 
    inline bool GetDisableNetworking() const { return m_disableNetworking; }
    inline bool DisableNetworkingHasBeenSet() const { return m_disableNetworkingHasBeenSet; }
    inline void SetDisableNetworking(bool value) { m_disableNetworkingHasBeenSet = true; m_disableNetworking = value; }
    inline ContainerDefinition& WithDisableNetworking(bool value) { SetDisableNetworking(value); return *this;}
 
 
    inline bool GetPrivileged() const { return m_privileged; }
    inline bool PrivilegedHasBeenSet() const { return m_privilegedHasBeenSet; }
    inline void SetPrivileged(bool value) { m_privilegedHasBeenSet = true; m_privileged = value; }
    inline ContainerDefinition& WithPrivileged(bool value) { SetPrivileged(value); return *this;}
 
 
    inline bool GetReadonlyRootFilesystem() const { return m_readonlyRootFilesystem; }
    inline bool ReadonlyRootFilesystemHasBeenSet() const { return m_readonlyRootFilesystemHasBeenSet; }
    inline void SetReadonlyRootFilesystem(bool value) { m_readonlyRootFilesystemHasBeenSet = true; m_readonlyRootFilesystem = value; }
    inline ContainerDefinition& WithReadonlyRootFilesystem(bool value) { SetReadonlyRootFilesystem(value); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetDnsServers() const { return m_dnsServers; }
    inline bool DnsServersHasBeenSet() const { return m_dnsServersHasBeenSet; }
    template<typename DnsServersT = Aws::Vector<Aws::String>>
    void SetDnsServers(DnsServersT&& value) { m_dnsServersHasBeenSet = true; m_dnsServers = std::forward<DnsServersT>(value); }
    template<typename DnsServersT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithDnsServers(DnsServersT&& value) { SetDnsServers(std::forward<DnsServersT>(value)); return *this;}
    template<typename DnsServersT = Aws::String>
    ContainerDefinition& AddDnsServers(DnsServersT&& value) { m_dnsServersHasBeenSet = true; m_dnsServers.emplace_back(std::forward<DnsServersT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetDnsSearchDomains() const { return m_dnsSearchDomains; }
    inline bool DnsSearchDomainsHasBeenSet() const { return m_dnsSearchDomainsHasBeenSet; }
    template<typename DnsSearchDomainsT = Aws::Vector<Aws::String>>
    void SetDnsSearchDomains(DnsSearchDomainsT&& value) { m_dnsSearchDomainsHasBeenSet = true; m_dnsSearchDomains = std::forward<DnsSearchDomainsT>(value); }
    template<typename DnsSearchDomainsT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithDnsSearchDomains(DnsSearchDomainsT&& value) { SetDnsSearchDomains(std::forward<DnsSearchDomainsT>(value)); return *this;}
    template<typename DnsSearchDomainsT = Aws::String>
    ContainerDefinition& AddDnsSearchDomains(DnsSearchDomainsT&& value) { m_dnsSearchDomainsHasBeenSet = true; m_dnsSearchDomains.emplace_back(std::forward<DnsSearchDomainsT>(value)); return *this; }
 
 
    inline const Aws::Vector<HostEntry>& GetExtraHosts() const { return m_extraHosts; }
    inline bool ExtraHostsHasBeenSet() const { return m_extraHostsHasBeenSet; }
    template<typename ExtraHostsT = Aws::Vector<HostEntry>>
    void SetExtraHosts(ExtraHostsT&& value) { m_extraHostsHasBeenSet = true; m_extraHosts = std::forward<ExtraHostsT>(value); }
    template<typename ExtraHostsT = Aws::Vector<HostEntry>>
    ContainerDefinition& WithExtraHosts(ExtraHostsT&& value) { SetExtraHosts(std::forward<ExtraHostsT>(value)); return *this;}
    template<typename ExtraHostsT = HostEntry>
    ContainerDefinition& AddExtraHosts(ExtraHostsT&& value) { m_extraHostsHasBeenSet = true; m_extraHosts.emplace_back(std::forward<ExtraHostsT>(value)); return *this; }
 
 
    inline const Aws::Vector<Aws::String>& GetDockerSecurityOptions() const { return m_dockerSecurityOptions; }
    inline bool DockerSecurityOptionsHasBeenSet() const { return m_dockerSecurityOptionsHasBeenSet; }
    template<typename DockerSecurityOptionsT = Aws::Vector<Aws::String>>
    void SetDockerSecurityOptions(DockerSecurityOptionsT&& value) { m_dockerSecurityOptionsHasBeenSet = true; m_dockerSecurityOptions = std::forward<DockerSecurityOptionsT>(value); }
    template<typename DockerSecurityOptionsT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithDockerSecurityOptions(DockerSecurityOptionsT&& value) { SetDockerSecurityOptions(std::forward<DockerSecurityOptionsT>(value)); return *this;}
    template<typename DockerSecurityOptionsT = Aws::String>
    ContainerDefinition& AddDockerSecurityOptions(DockerSecurityOptionsT&& value) { m_dockerSecurityOptionsHasBeenSet = true; m_dockerSecurityOptions.emplace_back(std::forward<DockerSecurityOptionsT>(value)); return *this; }
 
 
    inline bool GetInteractive() const { return m_interactive; }
    inline bool InteractiveHasBeenSet() const { return m_interactiveHasBeenSet; }
    inline void SetInteractive(bool value) { m_interactiveHasBeenSet = true; m_interactive = value; }
    inline ContainerDefinition& WithInteractive(bool value) { SetInteractive(value); return *this;}
 
 
    inline bool GetPseudoTerminal() const { return m_pseudoTerminal; }
    inline bool PseudoTerminalHasBeenSet() const { return m_pseudoTerminalHasBeenSet; }
    inline void SetPseudoTerminal(bool value) { m_pseudoTerminalHasBeenSet = true; m_pseudoTerminal = value; }
    inline ContainerDefinition& WithPseudoTerminal(bool value) { SetPseudoTerminal(value); return *this;}
 
 
    inline const Aws::Map<Aws::String, Aws::String>& GetDockerLabels() const { return m_dockerLabels; }
    inline bool DockerLabelsHasBeenSet() const { return m_dockerLabelsHasBeenSet; }
    template<typename DockerLabelsT = Aws::Map<Aws::String, Aws::String>>
    void SetDockerLabels(DockerLabelsT&& value) { m_dockerLabelsHasBeenSet = true; m_dockerLabels = std::forward<DockerLabelsT>(value); }
    template<typename DockerLabelsT = Aws::Map<Aws::String, Aws::String>>
    ContainerDefinition& WithDockerLabels(DockerLabelsT&& value) { SetDockerLabels(std::forward<DockerLabelsT>(value)); return *this;}
    template<typename DockerLabelsKeyT = Aws::String, typename DockerLabelsValueT = Aws::String>
    ContainerDefinition& AddDockerLabels(DockerLabelsKeyT&& key, DockerLabelsValueT&& value) {
      m_dockerLabelsHasBeenSet = true; m_dockerLabels.emplace(std::forward<DockerLabelsKeyT>(key), std::forward<DockerLabelsValueT>(value)); return *this;
    }
 
 
    inline const Aws::Vector<Ulimit>& GetUlimits() const { return m_ulimits; }
    inline bool UlimitsHasBeenSet() const { return m_ulimitsHasBeenSet; }
    template<typename UlimitsT = Aws::Vector<Ulimit>>
    void SetUlimits(UlimitsT&& value) { m_ulimitsHasBeenSet = true; m_ulimits = std::forward<UlimitsT>(value); }
    template<typename UlimitsT = Aws::Vector<Ulimit>>
    ContainerDefinition& WithUlimits(UlimitsT&& value) { SetUlimits(std::forward<UlimitsT>(value)); return *this;}
    template<typename UlimitsT = Ulimit>
    ContainerDefinition& AddUlimits(UlimitsT&& value) { m_ulimitsHasBeenSet = true; m_ulimits.emplace_back(std::forward<UlimitsT>(value)); return *this; }
 
 
    inline const LogConfiguration& GetLogConfiguration() const { return m_logConfiguration; }
    inline bool LogConfigurationHasBeenSet() const { return m_logConfigurationHasBeenSet; }
    template<typename LogConfigurationT = LogConfiguration>
    void SetLogConfiguration(LogConfigurationT&& value) { m_logConfigurationHasBeenSet = true; m_logConfiguration = std::forward<LogConfigurationT>(value); }
    template<typename LogConfigurationT = LogConfiguration>
    ContainerDefinition& WithLogConfiguration(LogConfigurationT&& value) { SetLogConfiguration(std::forward<LogConfigurationT>(value)); return *this;}
 
 
    inline const HealthCheck& GetHealthCheck() const { return m_healthCheck; }
    inline bool HealthCheckHasBeenSet() const { return m_healthCheckHasBeenSet; }
    template<typename HealthCheckT = HealthCheck>
    void SetHealthCheck(HealthCheckT&& value) { m_healthCheckHasBeenSet = true; m_healthCheck = std::forward<HealthCheckT>(value); }
    template<typename HealthCheckT = HealthCheck>
    ContainerDefinition& WithHealthCheck(HealthCheckT&& value) { SetHealthCheck(std::forward<HealthCheckT>(value)); return *this;}
 
 
    inline const Aws::Vector<SystemControl>& GetSystemControls() const { return m_systemControls; }
    inline bool SystemControlsHasBeenSet() const { return m_systemControlsHasBeenSet; }
    template<typename SystemControlsT = Aws::Vector<SystemControl>>
    void SetSystemControls(SystemControlsT&& value) { m_systemControlsHasBeenSet = true; m_systemControls = std::forward<SystemControlsT>(value); }
    template<typename SystemControlsT = Aws::Vector<SystemControl>>
    ContainerDefinition& WithSystemControls(SystemControlsT&& value) { SetSystemControls(std::forward<SystemControlsT>(value)); return *this;}
    template<typename SystemControlsT = SystemControl>
    ContainerDefinition& AddSystemControls(SystemControlsT&& value) { m_systemControlsHasBeenSet = true; m_systemControls.emplace_back(std::forward<SystemControlsT>(value)); return *this; }
 
 
    inline const Aws::Vector<ResourceRequirement>& GetResourceRequirements() const { return m_resourceRequirements; }
    inline bool ResourceRequirementsHasBeenSet() const { return m_resourceRequirementsHasBeenSet; }
    template<typename ResourceRequirementsT = Aws::Vector<ResourceRequirement>>
    void SetResourceRequirements(ResourceRequirementsT&& value) { m_resourceRequirementsHasBeenSet = true; m_resourceRequirements = std::forward<ResourceRequirementsT>(value); }
    template<typename ResourceRequirementsT = Aws::Vector<ResourceRequirement>>
    ContainerDefinition& WithResourceRequirements(ResourceRequirementsT&& value) { SetResourceRequirements(std::forward<ResourceRequirementsT>(value)); return *this;}
    template<typename ResourceRequirementsT = ResourceRequirement>
    ContainerDefinition& AddResourceRequirements(ResourceRequirementsT&& value) { m_resourceRequirementsHasBeenSet = true; m_resourceRequirements.emplace_back(std::forward<ResourceRequirementsT>(value)); return *this; }
 
 
    inline const FirelensConfiguration& GetFirelensConfiguration() const { return m_firelensConfiguration; }
    inline bool FirelensConfigurationHasBeenSet() const { return m_firelensConfigurationHasBeenSet; }
    template<typename FirelensConfigurationT = FirelensConfiguration>
    void SetFirelensConfiguration(FirelensConfigurationT&& value) { m_firelensConfigurationHasBeenSet = true; m_firelensConfiguration = std::forward<FirelensConfigurationT>(value); }
    template<typename FirelensConfigurationT = FirelensConfiguration>
    ContainerDefinition& WithFirelensConfiguration(FirelensConfigurationT&& value) { SetFirelensConfiguration(std::forward<FirelensConfigurationT>(value)); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetCredentialSpecs() const { return m_credentialSpecs; }
    inline bool CredentialSpecsHasBeenSet() const { return m_credentialSpecsHasBeenSet; }
    template<typename CredentialSpecsT = Aws::Vector<Aws::String>>
    void SetCredentialSpecs(CredentialSpecsT&& value) { m_credentialSpecsHasBeenSet = true; m_credentialSpecs = std::forward<CredentialSpecsT>(value); }
    template<typename CredentialSpecsT = Aws::Vector<Aws::String>>
    ContainerDefinition& WithCredentialSpecs(CredentialSpecsT&& value) { SetCredentialSpecs(std::forward<CredentialSpecsT>(value)); return *this;}
    template<typename CredentialSpecsT = Aws::String>
    ContainerDefinition& AddCredentialSpecs(CredentialSpecsT&& value) { m_credentialSpecsHasBeenSet = true; m_credentialSpecs.emplace_back(std::forward<CredentialSpecsT>(value)); return *this; }
  private:
 
    Aws::String m_name;
    bool m_nameHasBeenSet = false;
 
    Aws::String m_image;
    bool m_imageHasBeenSet = false;
 
    RepositoryCredentials m_repositoryCredentials;
    bool m_repositoryCredentialsHasBeenSet = false;
 
    int m_cpu{0};
    bool m_cpuHasBeenSet = false;
 
    int m_memory{0};
    bool m_memoryHasBeenSet = false;
 
    int m_memoryReservation{0};
    bool m_memoryReservationHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_links;
    bool m_linksHasBeenSet = false;
 
    Aws::Vector<PortMapping> m_portMappings;
    bool m_portMappingsHasBeenSet = false;
 
    bool m_essential{false};
    bool m_essentialHasBeenSet = false;
 
    ContainerRestartPolicy m_restartPolicy;
    bool m_restartPolicyHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_entryPoint;
    bool m_entryPointHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_command;
    bool m_commandHasBeenSet = false;
 
    Aws::Vector<KeyValuePair> m_environment;
    bool m_environmentHasBeenSet = false;
 
    Aws::Vector<EnvironmentFile> m_environmentFiles;
    bool m_environmentFilesHasBeenSet = false;
 
    Aws::Vector<MountPoint> m_mountPoints;
    bool m_mountPointsHasBeenSet = false;
 
    Aws::Vector<VolumeFrom> m_volumesFrom;
    bool m_volumesFromHasBeenSet = false;
 
    LinuxParameters m_linuxParameters;
    bool m_linuxParametersHasBeenSet = false;
 
    Aws::Vector<Secret> m_secrets;
    bool m_secretsHasBeenSet = false;
 
    Aws::Vector<ContainerDependency> m_dependsOn;
    bool m_dependsOnHasBeenSet = false;
 
    int m_startTimeout{0};
    bool m_startTimeoutHasBeenSet = false;
 
    int m_stopTimeout{0};
    bool m_stopTimeoutHasBeenSet = false;
 
    VersionConsistency m_versionConsistency{VersionConsistency::NOT_SET};
    bool m_versionConsistencyHasBeenSet = false;
 
    Aws::String m_hostname;
    bool m_hostnameHasBeenSet = false;
 
    Aws::String m_user;
    bool m_userHasBeenSet = false;
 
    Aws::String m_workingDirectory;
    bool m_workingDirectoryHasBeenSet = false;
 
    bool m_disableNetworking{false};
    bool m_disableNetworkingHasBeenSet = false;
 
    bool m_privileged{false};
    bool m_privilegedHasBeenSet = false;
 
    bool m_readonlyRootFilesystem{false};
    bool m_readonlyRootFilesystemHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_dnsServers;
    bool m_dnsServersHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_dnsSearchDomains;
    bool m_dnsSearchDomainsHasBeenSet = false;
 
    Aws::Vector<HostEntry> m_extraHosts;
    bool m_extraHostsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_dockerSecurityOptions;
    bool m_dockerSecurityOptionsHasBeenSet = false;
 
    bool m_interactive{false};
    bool m_interactiveHasBeenSet = false;
 
    bool m_pseudoTerminal{false};
    bool m_pseudoTerminalHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_dockerLabels;
    bool m_dockerLabelsHasBeenSet = false;
 
    Aws::Vector<Ulimit> m_ulimits;
    bool m_ulimitsHasBeenSet = false;
 
    LogConfiguration m_logConfiguration;
    bool m_logConfigurationHasBeenSet = false;
 
    HealthCheck m_healthCheck;
    bool m_healthCheckHasBeenSet = false;
 
    Aws::Vector<SystemControl> m_systemControls;
    bool m_systemControlsHasBeenSet = false;
 
    Aws::Vector<ResourceRequirement> m_resourceRequirements;
    bool m_resourceRequirementsHasBeenSet = false;
 
    FirelensConfiguration m_firelensConfiguration;
    bool m_firelensConfigurationHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_credentialSpecs;
    bool m_credentialSpecsHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ECS
} // namespace Aws