ContainerGroupDefinition.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/gamelift/GameLift_EXPORTS.h>
#include <aws/gamelift/model/ContainerGroupDefinitionStatus.h>
#include <aws/gamelift/model/ContainerGroupType.h>
#include <aws/gamelift/model/ContainerOperatingSystem.h>
#include <aws/gamelift/model/GameServerContainerDefinition.h>
#include <aws/gamelift/model/SupportContainerDefinition.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace GameLift {
namespace Model {
 
class ContainerGroupDefinition {
 public:
  AWS_GAMELIFT_API ContainerGroupDefinition() = default;
  AWS_GAMELIFT_API ContainerGroupDefinition(Aws::Utils::Json::JsonView jsonValue);
  AWS_GAMELIFT_API ContainerGroupDefinition& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetContainerGroupDefinitionArn() const { return m_containerGroupDefinitionArn; }
  inline bool ContainerGroupDefinitionArnHasBeenSet() const { return m_containerGroupDefinitionArnHasBeenSet; }
  template <typename ContainerGroupDefinitionArnT = Aws::String>
  void SetContainerGroupDefinitionArn(ContainerGroupDefinitionArnT&& value) {
    m_containerGroupDefinitionArnHasBeenSet = true;
    m_containerGroupDefinitionArn = std::forward<ContainerGroupDefinitionArnT>(value);
  }
  template <typename ContainerGroupDefinitionArnT = Aws::String>
  ContainerGroupDefinition& WithContainerGroupDefinitionArn(ContainerGroupDefinitionArnT&& value) {
    SetContainerGroupDefinitionArn(std::forward<ContainerGroupDefinitionArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreationTime() const { return m_creationTime; }
  inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  void SetCreationTime(CreationTimeT&& value) {
    m_creationTimeHasBeenSet = true;
    m_creationTime = std::forward<CreationTimeT>(value);
  }
  template <typename CreationTimeT = Aws::Utils::DateTime>
  ContainerGroupDefinition& WithCreationTime(CreationTimeT&& value) {
    SetCreationTime(std::forward<CreationTimeT>(value));
    return *this;
  }
 
 
  inline ContainerOperatingSystem GetOperatingSystem() const { return m_operatingSystem; }
  inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
  inline void SetOperatingSystem(ContainerOperatingSystem value) {
    m_operatingSystemHasBeenSet = true;
    m_operatingSystem = value;
  }
  inline ContainerGroupDefinition& WithOperatingSystem(ContainerOperatingSystem value) {
    SetOperatingSystem(value);
    return *this;
  }
 
 
  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>
  ContainerGroupDefinition& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline ContainerGroupType GetContainerGroupType() const { return m_containerGroupType; }
  inline bool ContainerGroupTypeHasBeenSet() const { return m_containerGroupTypeHasBeenSet; }
  inline void SetContainerGroupType(ContainerGroupType value) {
    m_containerGroupTypeHasBeenSet = true;
    m_containerGroupType = value;
  }
  inline ContainerGroupDefinition& WithContainerGroupType(ContainerGroupType value) {
    SetContainerGroupType(value);
    return *this;
  }
 
 
  inline int GetTotalMemoryLimitMebibytes() const { return m_totalMemoryLimitMebibytes; }
  inline bool TotalMemoryLimitMebibytesHasBeenSet() const { return m_totalMemoryLimitMebibytesHasBeenSet; }
  inline void SetTotalMemoryLimitMebibytes(int value) {
    m_totalMemoryLimitMebibytesHasBeenSet = true;
    m_totalMemoryLimitMebibytes = value;
  }
  inline ContainerGroupDefinition& WithTotalMemoryLimitMebibytes(int value) {
    SetTotalMemoryLimitMebibytes(value);
    return *this;
  }
 
 
  inline double GetTotalVcpuLimit() const { return m_totalVcpuLimit; }
  inline bool TotalVcpuLimitHasBeenSet() const { return m_totalVcpuLimitHasBeenSet; }
  inline void SetTotalVcpuLimit(double value) {
    m_totalVcpuLimitHasBeenSet = true;
    m_totalVcpuLimit = value;
  }
  inline ContainerGroupDefinition& WithTotalVcpuLimit(double value) {
    SetTotalVcpuLimit(value);
    return *this;
  }
 
 
  inline const GameServerContainerDefinition& GetGameServerContainerDefinition() const { return m_gameServerContainerDefinition; }
  inline bool GameServerContainerDefinitionHasBeenSet() const { return m_gameServerContainerDefinitionHasBeenSet; }
  template <typename GameServerContainerDefinitionT = GameServerContainerDefinition>
  void SetGameServerContainerDefinition(GameServerContainerDefinitionT&& value) {
    m_gameServerContainerDefinitionHasBeenSet = true;
    m_gameServerContainerDefinition = std::forward<GameServerContainerDefinitionT>(value);
  }
  template <typename GameServerContainerDefinitionT = GameServerContainerDefinition>
  ContainerGroupDefinition& WithGameServerContainerDefinition(GameServerContainerDefinitionT&& value) {
    SetGameServerContainerDefinition(std::forward<GameServerContainerDefinitionT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SupportContainerDefinition>& GetSupportContainerDefinitions() const { return m_supportContainerDefinitions; }
  inline bool SupportContainerDefinitionsHasBeenSet() const { return m_supportContainerDefinitionsHasBeenSet; }
  template <typename SupportContainerDefinitionsT = Aws::Vector<SupportContainerDefinition>>
  void SetSupportContainerDefinitions(SupportContainerDefinitionsT&& value) {
    m_supportContainerDefinitionsHasBeenSet = true;
    m_supportContainerDefinitions = std::forward<SupportContainerDefinitionsT>(value);
  }
  template <typename SupportContainerDefinitionsT = Aws::Vector<SupportContainerDefinition>>
  ContainerGroupDefinition& WithSupportContainerDefinitions(SupportContainerDefinitionsT&& value) {
    SetSupportContainerDefinitions(std::forward<SupportContainerDefinitionsT>(value));
    return *this;
  }
  template <typename SupportContainerDefinitionsT = SupportContainerDefinition>
  ContainerGroupDefinition& AddSupportContainerDefinitions(SupportContainerDefinitionsT&& value) {
    m_supportContainerDefinitionsHasBeenSet = true;
    m_supportContainerDefinitions.emplace_back(std::forward<SupportContainerDefinitionsT>(value));
    return *this;
  }
 
 
  inline int GetVersionNumber() const { return m_versionNumber; }
  inline bool VersionNumberHasBeenSet() const { return m_versionNumberHasBeenSet; }
  inline void SetVersionNumber(int value) {
    m_versionNumberHasBeenSet = true;
    m_versionNumber = value;
  }
  inline ContainerGroupDefinition& WithVersionNumber(int value) {
    SetVersionNumber(value);
    return *this;
  }
 
 
  inline const Aws::String& GetVersionDescription() const { return m_versionDescription; }
  inline bool VersionDescriptionHasBeenSet() const { return m_versionDescriptionHasBeenSet; }
  template <typename VersionDescriptionT = Aws::String>
  void SetVersionDescription(VersionDescriptionT&& value) {
    m_versionDescriptionHasBeenSet = true;
    m_versionDescription = std::forward<VersionDescriptionT>(value);
  }
  template <typename VersionDescriptionT = Aws::String>
  ContainerGroupDefinition& WithVersionDescription(VersionDescriptionT&& value) {
    SetVersionDescription(std::forward<VersionDescriptionT>(value));
    return *this;
  }
 
 
  inline ContainerGroupDefinitionStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(ContainerGroupDefinitionStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline ContainerGroupDefinition& WithStatus(ContainerGroupDefinitionStatus value) {
    SetStatus(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>
  ContainerGroupDefinition& WithStatusReason(StatusReasonT&& value) {
    SetStatusReason(std::forward<StatusReasonT>(value));
    return *this;
  }
 private:
  Aws::String m_containerGroupDefinitionArn;
 
  Aws::Utils::DateTime m_creationTime{};
 
  ContainerOperatingSystem m_operatingSystem{ContainerOperatingSystem::NOT_SET};
 
  Aws::String m_name;
 
  ContainerGroupType m_containerGroupType{ContainerGroupType::NOT_SET};
 
  int m_totalMemoryLimitMebibytes{0};
 
  double m_totalVcpuLimit{0.0};
 
  GameServerContainerDefinition m_gameServerContainerDefinition;
 
  Aws::Vector<SupportContainerDefinition> m_supportContainerDefinitions;
 
  int m_versionNumber{0};
 
  Aws::String m_versionDescription;
 
  ContainerGroupDefinitionStatus m_status{ContainerGroupDefinitionStatus::NOT_SET};
 
  Aws::String m_statusReason;
  bool m_containerGroupDefinitionArnHasBeenSet = false;
  bool m_creationTimeHasBeenSet = false;
  bool m_operatingSystemHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_containerGroupTypeHasBeenSet = false;
  bool m_totalMemoryLimitMebibytesHasBeenSet = false;
  bool m_totalVcpuLimitHasBeenSet = false;
  bool m_gameServerContainerDefinitionHasBeenSet = false;
  bool m_supportContainerDefinitionsHasBeenSet = false;
  bool m_versionNumberHasBeenSet = false;
  bool m_versionDescriptionHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_statusReasonHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GameLift
}  // namespace Aws