ContainerInstance.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/AgentUpdateStatus.h>
#include <aws/ecs/model/Attachment.h>
#include <aws/ecs/model/Attribute.h>
#include <aws/ecs/model/ContainerInstanceHealthStatus.h>
#include <aws/ecs/model/Resource.h>
#include <aws/ecs/model/Tag.h>
#include <aws/ecs/model/VersionInfo.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;
 
  Aws::String m_ec2InstanceId;
 
  Aws::String m_capacityProviderName;
 
  long long m_version{0};
 
  VersionInfo m_versionInfo;
 
  Aws::Vector<Resource> m_remainingResources;
 
  Aws::Vector<Resource> m_registeredResources;
 
  Aws::String m_status;
 
  Aws::String m_statusReason;
 
  bool m_agentConnected{false};
 
  int m_runningTasksCount{0};
 
  int m_pendingTasksCount{0};
 
  AgentUpdateStatus m_agentUpdateStatus{AgentUpdateStatus::NOT_SET};
 
  Aws::Vector<Attribute> m_attributes;
 
  Aws::Utils::DateTime m_registeredAt{};
 
  Aws::Vector<Attachment> m_attachments;
 
  Aws::Vector<Tag> m_tags;
 
  ContainerInstanceHealthStatus m_healthStatus;
  bool m_containerInstanceArnHasBeenSet = false;
  bool m_ec2InstanceIdHasBeenSet = false;
  bool m_capacityProviderNameHasBeenSet = false;
  bool m_versionHasBeenSet = false;
  bool m_versionInfoHasBeenSet = false;
  bool m_remainingResourcesHasBeenSet = false;
  bool m_registeredResourcesHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusReasonHasBeenSet = false;
  bool m_agentConnectedHasBeenSet = false;
  bool m_runningTasksCountHasBeenSet = false;
  bool m_pendingTasksCountHasBeenSet = false;
  bool m_agentUpdateStatusHasBeenSet = false;
  bool m_attributesHasBeenSet = false;
  bool m_registeredAtHasBeenSet = false;
  bool m_attachmentsHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_healthStatusHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ECS
}  // namespace Aws