ContainerInstance.h

 
#pragma once
#include <aws/ecs/ECS_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ecs/model/VersionInfo.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ecs/model/AgentUpdateStatus.h>
#include <aws/core/utils/DateTime.h>
#include <aws/ecs/model/ContainerInstanceHealthStatus.h>
#include <aws/ecs/model/Resource.h>
#include <aws/ecs/model/Attribute.h>
#include <aws/ecs/model/Attachment.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 ContainerInstance
  {
  public:
    AWS_ECS_API ContainerInstance() = default;
    AWS_ECS_API ContainerInstance(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API ContainerInstance& operator=(Aws::Utils::Json::JsonView jsonValue);
    AWS_ECS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
 
    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>
    ContainerInstance& WithContainerInstanceArn(ContainerInstanceArnT&& value) { SetContainerInstanceArn(std::forward<ContainerInstanceArnT>(value)); return *this;}
 
 
    inline const Aws::String& GetEc2InstanceId() const { return m_ec2InstanceId; }
    inline bool Ec2InstanceIdHasBeenSet() const { return m_ec2InstanceIdHasBeenSet; }
    template<typename Ec2InstanceIdT = Aws::String>
    void SetEc2InstanceId(Ec2InstanceIdT&& value) { m_ec2InstanceIdHasBeenSet = true; m_ec2InstanceId = std::forward<Ec2InstanceIdT>(value); }
    template<typename Ec2InstanceIdT = Aws::String>
    ContainerInstance& WithEc2InstanceId(Ec2InstanceIdT&& value) { SetEc2InstanceId(std::forward<Ec2InstanceIdT>(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>
    ContainerInstance& WithCapacityProviderName(CapacityProviderNameT&& value) { SetCapacityProviderName(std::forward<CapacityProviderNameT>(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 ContainerInstance& WithVersion(long long value) { SetVersion(value); return *this;}
 
 
    inline const VersionInfo& GetVersionInfo() const { return m_versionInfo; }
    inline bool VersionInfoHasBeenSet() const { return m_versionInfoHasBeenSet; }
    template<typename VersionInfoT = VersionInfo>
    void SetVersionInfo(VersionInfoT&& value) { m_versionInfoHasBeenSet = true; m_versionInfo = std::forward<VersionInfoT>(value); }
    template<typename VersionInfoT = VersionInfo>
    ContainerInstance& WithVersionInfo(VersionInfoT&& value) { SetVersionInfo(std::forward<VersionInfoT>(value)); return *this;}
 
 
    inline const Aws::Vector<Resource>& GetRemainingResources() const { return m_remainingResources; }
    inline bool RemainingResourcesHasBeenSet() const { return m_remainingResourcesHasBeenSet; }
    template<typename RemainingResourcesT = Aws::Vector<Resource>>
    void SetRemainingResources(RemainingResourcesT&& value) { m_remainingResourcesHasBeenSet = true; m_remainingResources = std::forward<RemainingResourcesT>(value); }
    template<typename RemainingResourcesT = Aws::Vector<Resource>>
    ContainerInstance& WithRemainingResources(RemainingResourcesT&& value) { SetRemainingResources(std::forward<RemainingResourcesT>(value)); return *this;}
    template<typename RemainingResourcesT = Resource>
    ContainerInstance& AddRemainingResources(RemainingResourcesT&& value) { m_remainingResourcesHasBeenSet = true; m_remainingResources.emplace_back(std::forward<RemainingResourcesT>(value)); return *this; }
 
 
    inline const Aws::Vector<Resource>& GetRegisteredResources() const { return m_registeredResources; }
    inline bool RegisteredResourcesHasBeenSet() const { return m_registeredResourcesHasBeenSet; }
    template<typename RegisteredResourcesT = Aws::Vector<Resource>>
    void SetRegisteredResources(RegisteredResourcesT&& value) { m_registeredResourcesHasBeenSet = true; m_registeredResources = std::forward<RegisteredResourcesT>(value); }
    template<typename RegisteredResourcesT = Aws::Vector<Resource>>
    ContainerInstance& WithRegisteredResources(RegisteredResourcesT&& value) { SetRegisteredResources(std::forward<RegisteredResourcesT>(value)); return *this;}
    template<typename RegisteredResourcesT = Resource>
    ContainerInstance& AddRegisteredResources(RegisteredResourcesT&& value) { m_registeredResourcesHasBeenSet = true; m_registeredResources.emplace_back(std::forward<RegisteredResourcesT>(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>
    ContainerInstance& WithStatus(StatusT&& value) { SetStatus(std::forward<StatusT>(value)); return *this;}
 
 
    inline const Aws::String& GetStatusReason() const { return m_statusReason; }
    inline bool StatusReasonHasBeenSet() const { return m_statusReasonHasBeenSet; }
    template<typename StatusReasonT = Aws::String>
    void SetStatusReason(StatusReasonT&& value) { m_statusReasonHasBeenSet = true; m_statusReason = std::forward<StatusReasonT>(value); }
    template<typename StatusReasonT = Aws::String>
    ContainerInstance& WithStatusReason(StatusReasonT&& value) { SetStatusReason(std::forward<StatusReasonT>(value)); return *this;}
 
 
    inline bool GetAgentConnected() const { return m_agentConnected; }
    inline bool AgentConnectedHasBeenSet() const { return m_agentConnectedHasBeenSet; }
    inline void SetAgentConnected(bool value) { m_agentConnectedHasBeenSet = true; m_agentConnected = value; }
    inline ContainerInstance& WithAgentConnected(bool value) { SetAgentConnected(value); return *this;}
 
 
    inline int GetRunningTasksCount() const { return m_runningTasksCount; }
    inline bool RunningTasksCountHasBeenSet() const { return m_runningTasksCountHasBeenSet; }
    inline void SetRunningTasksCount(int value) { m_runningTasksCountHasBeenSet = true; m_runningTasksCount = value; }
    inline ContainerInstance& WithRunningTasksCount(int value) { SetRunningTasksCount(value); return *this;}
 
 
    inline int GetPendingTasksCount() const { return m_pendingTasksCount; }
    inline bool PendingTasksCountHasBeenSet() const { return m_pendingTasksCountHasBeenSet; }
    inline void SetPendingTasksCount(int value) { m_pendingTasksCountHasBeenSet = true; m_pendingTasksCount = value; }
    inline ContainerInstance& WithPendingTasksCount(int value) { SetPendingTasksCount(value); return *this;}
 
 
    inline AgentUpdateStatus GetAgentUpdateStatus() const { return m_agentUpdateStatus; }
    inline bool AgentUpdateStatusHasBeenSet() const { return m_agentUpdateStatusHasBeenSet; }
    inline void SetAgentUpdateStatus(AgentUpdateStatus value) { m_agentUpdateStatusHasBeenSet = true; m_agentUpdateStatus = value; }
    inline ContainerInstance& WithAgentUpdateStatus(AgentUpdateStatus value) { SetAgentUpdateStatus(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>>
    ContainerInstance& WithAttributes(AttributesT&& value) { SetAttributes(std::forward<AttributesT>(value)); return *this;}
    template<typename AttributesT = Attribute>
    ContainerInstance& AddAttributes(AttributesT&& value) { m_attributesHasBeenSet = true; m_attributes.emplace_back(std::forward<AttributesT>(value)); return *this; }
 
 
    inline const Aws::Utils::DateTime& GetRegisteredAt() const { return m_registeredAt; }
    inline bool RegisteredAtHasBeenSet() const { return m_registeredAtHasBeenSet; }
    template<typename RegisteredAtT = Aws::Utils::DateTime>
    void SetRegisteredAt(RegisteredAtT&& value) { m_registeredAtHasBeenSet = true; m_registeredAt = std::forward<RegisteredAtT>(value); }
    template<typename RegisteredAtT = Aws::Utils::DateTime>
    ContainerInstance& WithRegisteredAt(RegisteredAtT&& value) { SetRegisteredAt(std::forward<RegisteredAtT>(value)); return *this;}
 
 
    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>>
    ContainerInstance& WithAttachments(AttachmentsT&& value) { SetAttachments(std::forward<AttachmentsT>(value)); return *this;}
    template<typename AttachmentsT = Attachment>
    ContainerInstance& AddAttachments(AttachmentsT&& value) { m_attachmentsHasBeenSet = true; m_attachments.emplace_back(std::forward<AttachmentsT>(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>>
    ContainerInstance& WithTags(TagsT&& value) { SetTags(std::forward<TagsT>(value)); return *this;}
    template<typename TagsT = Tag>
    ContainerInstance& AddTags(TagsT&& value) { m_tagsHasBeenSet = true; m_tags.emplace_back(std::forward<TagsT>(value)); return *this; }
 
 
    inline const ContainerInstanceHealthStatus& GetHealthStatus() const { return m_healthStatus; }
    inline bool HealthStatusHasBeenSet() const { return m_healthStatusHasBeenSet; }
    template<typename HealthStatusT = ContainerInstanceHealthStatus>
    void SetHealthStatus(HealthStatusT&& value) { m_healthStatusHasBeenSet = true; m_healthStatus = std::forward<HealthStatusT>(value); }
    template<typename HealthStatusT = ContainerInstanceHealthStatus>
    ContainerInstance& WithHealthStatus(HealthStatusT&& value) { SetHealthStatus(std::forward<HealthStatusT>(value)); return *this;}
  private:
 
    Aws::String m_containerInstanceArn;
    bool m_containerInstanceArnHasBeenSet = false;
 
    Aws::String m_ec2InstanceId;
    bool m_ec2InstanceIdHasBeenSet = false;
 
    Aws::String m_capacityProviderName;
    bool m_capacityProviderNameHasBeenSet = false;
 
    long long m_version{0};
    bool m_versionHasBeenSet = false;
 
    VersionInfo m_versionInfo;
    bool m_versionInfoHasBeenSet = false;
 
    Aws::Vector<Resource> m_remainingResources;
    bool m_remainingResourcesHasBeenSet = false;
 
    Aws::Vector<Resource> m_registeredResources;
    bool m_registeredResourcesHasBeenSet = false;
 
    Aws::String m_status;
    bool m_statusHasBeenSet = false;
 
    Aws::String m_statusReason;
    bool m_statusReasonHasBeenSet = false;
 
    bool m_agentConnected{false};
    bool m_agentConnectedHasBeenSet = false;
 
    int m_runningTasksCount{0};
    bool m_runningTasksCountHasBeenSet = false;
 
    int m_pendingTasksCount{0};
    bool m_pendingTasksCountHasBeenSet = false;
 
    AgentUpdateStatus m_agentUpdateStatus{AgentUpdateStatus::NOT_SET};
    bool m_agentUpdateStatusHasBeenSet = false;
 
    Aws::Vector<Attribute> m_attributes;
    bool m_attributesHasBeenSet = false;
 
    Aws::Utils::DateTime m_registeredAt{};
    bool m_registeredAtHasBeenSet = false;
 
    Aws::Vector<Attachment> m_attachments;
    bool m_attachmentsHasBeenSet = false;
 
    Aws::Vector<Tag> m_tags;
    bool m_tagsHasBeenSet = false;
 
    ContainerInstanceHealthStatus m_healthStatus;
    bool m_healthStatusHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ECS
} // namespace Aws