ComputeNodeGroup.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/pcs/PCS_EXPORTS.h>
#include <aws/pcs/model/ComputeNodeGroupSlurmConfiguration.h>
#include <aws/pcs/model/ComputeNodeGroupStatus.h>
#include <aws/pcs/model/CustomLaunchTemplate.h>
#include <aws/pcs/model/ErrorInfo.h>
#include <aws/pcs/model/InstanceConfig.h>
#include <aws/pcs/model/NodeLifecycleActions.h>
#include <aws/pcs/model/PurchaseOption.h>
#include <aws/pcs/model/ScalingConfiguration.h>
#include <aws/pcs/model/SpotOptions.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace PCS {
namespace Model {
 
class ComputeNodeGroup {
 public:
  AWS_PCS_API ComputeNodeGroup() = default;
  AWS_PCS_API ComputeNodeGroup(Aws::Utils::Json::JsonView jsonValue);
  AWS_PCS_API ComputeNodeGroup& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_PCS_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>
  ComputeNodeGroup& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  ComputeNodeGroup& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  ComputeNodeGroup& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterId() const { return m_clusterId; }
  inline bool ClusterIdHasBeenSet() const { return m_clusterIdHasBeenSet; }
  template <typename ClusterIdT = Aws::String>
  void SetClusterId(ClusterIdT&& value) {
    m_clusterIdHasBeenSet = true;
    m_clusterId = std::forward<ClusterIdT>(value);
  }
  template <typename ClusterIdT = Aws::String>
  ComputeNodeGroup& WithClusterId(ClusterIdT&& value) {
    SetClusterId(std::forward<ClusterIdT>(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>
  ComputeNodeGroup& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetModifiedAt() const { return m_modifiedAt; }
  inline bool ModifiedAtHasBeenSet() const { return m_modifiedAtHasBeenSet; }
  template <typename ModifiedAtT = Aws::Utils::DateTime>
  void SetModifiedAt(ModifiedAtT&& value) {
    m_modifiedAtHasBeenSet = true;
    m_modifiedAt = std::forward<ModifiedAtT>(value);
  }
  template <typename ModifiedAtT = Aws::Utils::DateTime>
  ComputeNodeGroup& WithModifiedAt(ModifiedAtT&& value) {
    SetModifiedAt(std::forward<ModifiedAtT>(value));
    return *this;
  }
 
 
  inline ComputeNodeGroupStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(ComputeNodeGroupStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline ComputeNodeGroup& WithStatus(ComputeNodeGroupStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAmiId() const { return m_amiId; }
  inline bool AmiIdHasBeenSet() const { return m_amiIdHasBeenSet; }
  template <typename AmiIdT = Aws::String>
  void SetAmiId(AmiIdT&& value) {
    m_amiIdHasBeenSet = true;
    m_amiId = std::forward<AmiIdT>(value);
  }
  template <typename AmiIdT = Aws::String>
  ComputeNodeGroup& WithAmiId(AmiIdT&& value) {
    SetAmiId(std::forward<AmiIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSubnetIds() const { return m_subnetIds; }
  inline bool SubnetIdsHasBeenSet() const { return m_subnetIdsHasBeenSet; }
  template <typename SubnetIdsT = Aws::Vector<Aws::String>>
  void SetSubnetIds(SubnetIdsT&& value) {
    m_subnetIdsHasBeenSet = true;
    m_subnetIds = std::forward<SubnetIdsT>(value);
  }
  template <typename SubnetIdsT = Aws::Vector<Aws::String>>
  ComputeNodeGroup& WithSubnetIds(SubnetIdsT&& value) {
    SetSubnetIds(std::forward<SubnetIdsT>(value));
    return *this;
  }
  template <typename SubnetIdsT = Aws::String>
  ComputeNodeGroup& AddSubnetIds(SubnetIdsT&& value) {
    m_subnetIdsHasBeenSet = true;
    m_subnetIds.emplace_back(std::forward<SubnetIdsT>(value));
    return *this;
  }
 
 
  inline PurchaseOption GetPurchaseOption() const { return m_purchaseOption; }
  inline bool PurchaseOptionHasBeenSet() const { return m_purchaseOptionHasBeenSet; }
  inline void SetPurchaseOption(PurchaseOption value) {
    m_purchaseOptionHasBeenSet = true;
    m_purchaseOption = value;
  }
  inline ComputeNodeGroup& WithPurchaseOption(PurchaseOption value) {
    SetPurchaseOption(value);
    return *this;
  }
 
 
  inline const CustomLaunchTemplate& GetCustomLaunchTemplate() const { return m_customLaunchTemplate; }
  inline bool CustomLaunchTemplateHasBeenSet() const { return m_customLaunchTemplateHasBeenSet; }
  template <typename CustomLaunchTemplateT = CustomLaunchTemplate>
  void SetCustomLaunchTemplate(CustomLaunchTemplateT&& value) {
    m_customLaunchTemplateHasBeenSet = true;
    m_customLaunchTemplate = std::forward<CustomLaunchTemplateT>(value);
  }
  template <typename CustomLaunchTemplateT = CustomLaunchTemplate>
  ComputeNodeGroup& WithCustomLaunchTemplate(CustomLaunchTemplateT&& value) {
    SetCustomLaunchTemplate(std::forward<CustomLaunchTemplateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIamInstanceProfileArn() const { return m_iamInstanceProfileArn; }
  inline bool IamInstanceProfileArnHasBeenSet() const { return m_iamInstanceProfileArnHasBeenSet; }
  template <typename IamInstanceProfileArnT = Aws::String>
  void SetIamInstanceProfileArn(IamInstanceProfileArnT&& value) {
    m_iamInstanceProfileArnHasBeenSet = true;
    m_iamInstanceProfileArn = std::forward<IamInstanceProfileArnT>(value);
  }
  template <typename IamInstanceProfileArnT = Aws::String>
  ComputeNodeGroup& WithIamInstanceProfileArn(IamInstanceProfileArnT&& value) {
    SetIamInstanceProfileArn(std::forward<IamInstanceProfileArnT>(value));
    return *this;
  }
 
 
  inline const ScalingConfiguration& GetScalingConfiguration() const { return m_scalingConfiguration; }
  inline bool ScalingConfigurationHasBeenSet() const { return m_scalingConfigurationHasBeenSet; }
  template <typename ScalingConfigurationT = ScalingConfiguration>
  void SetScalingConfiguration(ScalingConfigurationT&& value) {
    m_scalingConfigurationHasBeenSet = true;
    m_scalingConfiguration = std::forward<ScalingConfigurationT>(value);
  }
  template <typename ScalingConfigurationT = ScalingConfiguration>
  ComputeNodeGroup& WithScalingConfiguration(ScalingConfigurationT&& value) {
    SetScalingConfiguration(std::forward<ScalingConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<InstanceConfig>& GetInstanceConfigs() const { return m_instanceConfigs; }
  inline bool InstanceConfigsHasBeenSet() const { return m_instanceConfigsHasBeenSet; }
  template <typename InstanceConfigsT = Aws::Vector<InstanceConfig>>
  void SetInstanceConfigs(InstanceConfigsT&& value) {
    m_instanceConfigsHasBeenSet = true;
    m_instanceConfigs = std::forward<InstanceConfigsT>(value);
  }
  template <typename InstanceConfigsT = Aws::Vector<InstanceConfig>>
  ComputeNodeGroup& WithInstanceConfigs(InstanceConfigsT&& value) {
    SetInstanceConfigs(std::forward<InstanceConfigsT>(value));
    return *this;
  }
  template <typename InstanceConfigsT = InstanceConfig>
  ComputeNodeGroup& AddInstanceConfigs(InstanceConfigsT&& value) {
    m_instanceConfigsHasBeenSet = true;
    m_instanceConfigs.emplace_back(std::forward<InstanceConfigsT>(value));
    return *this;
  }
 
 
  inline const SpotOptions& GetSpotOptions() const { return m_spotOptions; }
  inline bool SpotOptionsHasBeenSet() const { return m_spotOptionsHasBeenSet; }
  template <typename SpotOptionsT = SpotOptions>
  void SetSpotOptions(SpotOptionsT&& value) {
    m_spotOptionsHasBeenSet = true;
    m_spotOptions = std::forward<SpotOptionsT>(value);
  }
  template <typename SpotOptionsT = SpotOptions>
  ComputeNodeGroup& WithSpotOptions(SpotOptionsT&& value) {
    SetSpotOptions(std::forward<SpotOptionsT>(value));
    return *this;
  }
 
 
  inline const ComputeNodeGroupSlurmConfiguration& GetSlurmConfiguration() const { return m_slurmConfiguration; }
  inline bool SlurmConfigurationHasBeenSet() const { return m_slurmConfigurationHasBeenSet; }
  template <typename SlurmConfigurationT = ComputeNodeGroupSlurmConfiguration>
  void SetSlurmConfiguration(SlurmConfigurationT&& value) {
    m_slurmConfigurationHasBeenSet = true;
    m_slurmConfiguration = std::forward<SlurmConfigurationT>(value);
  }
  template <typename SlurmConfigurationT = ComputeNodeGroupSlurmConfiguration>
  ComputeNodeGroup& WithSlurmConfiguration(SlurmConfigurationT&& value) {
    SetSlurmConfiguration(std::forward<SlurmConfigurationT>(value));
    return *this;
  }
 
 
  inline const NodeLifecycleActions& GetNodeLifecycleActions() const { return m_nodeLifecycleActions; }
  inline bool NodeLifecycleActionsHasBeenSet() const { return m_nodeLifecycleActionsHasBeenSet; }
  template <typename NodeLifecycleActionsT = NodeLifecycleActions>
  void SetNodeLifecycleActions(NodeLifecycleActionsT&& value) {
    m_nodeLifecycleActionsHasBeenSet = true;
    m_nodeLifecycleActions = std::forward<NodeLifecycleActionsT>(value);
  }
  template <typename NodeLifecycleActionsT = NodeLifecycleActions>
  ComputeNodeGroup& WithNodeLifecycleActions(NodeLifecycleActionsT&& value) {
    SetNodeLifecycleActions(std::forward<NodeLifecycleActionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ErrorInfo>& GetErrorInfo() const { return m_errorInfo; }
  inline bool ErrorInfoHasBeenSet() const { return m_errorInfoHasBeenSet; }
  template <typename ErrorInfoT = Aws::Vector<ErrorInfo>>
  void SetErrorInfo(ErrorInfoT&& value) {
    m_errorInfoHasBeenSet = true;
    m_errorInfo = std::forward<ErrorInfoT>(value);
  }
  template <typename ErrorInfoT = Aws::Vector<ErrorInfo>>
  ComputeNodeGroup& WithErrorInfo(ErrorInfoT&& value) {
    SetErrorInfo(std::forward<ErrorInfoT>(value));
    return *this;
  }
  template <typename ErrorInfoT = ErrorInfo>
  ComputeNodeGroup& AddErrorInfo(ErrorInfoT&& value) {
    m_errorInfoHasBeenSet = true;
    m_errorInfo.emplace_back(std::forward<ErrorInfoT>(value));
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_id;
 
  Aws::String m_arn;
 
  Aws::String m_clusterId;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::Utils::DateTime m_modifiedAt{};
 
  ComputeNodeGroupStatus m_status{ComputeNodeGroupStatus::NOT_SET};
 
  Aws::String m_amiId;
 
  Aws::Vector<Aws::String> m_subnetIds;
 
  PurchaseOption m_purchaseOption{PurchaseOption::NOT_SET};
 
  CustomLaunchTemplate m_customLaunchTemplate;
 
  Aws::String m_iamInstanceProfileArn;
 
  ScalingConfiguration m_scalingConfiguration;
 
  Aws::Vector<InstanceConfig> m_instanceConfigs;
 
  SpotOptions m_spotOptions;
 
  ComputeNodeGroupSlurmConfiguration m_slurmConfiguration;
 
  NodeLifecycleActions m_nodeLifecycleActions;
 
  Aws::Vector<ErrorInfo> m_errorInfo;
  bool m_nameHasBeenSet = false;
  bool m_idHasBeenSet = false;
  bool m_arnHasBeenSet = false;
  bool m_clusterIdHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_modifiedAtHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_amiIdHasBeenSet = false;
  bool m_subnetIdsHasBeenSet = false;
  bool m_purchaseOptionHasBeenSet = false;
  bool m_customLaunchTemplateHasBeenSet = false;
  bool m_iamInstanceProfileArnHasBeenSet = false;
  bool m_scalingConfigurationHasBeenSet = false;
  bool m_instanceConfigsHasBeenSet = false;
  bool m_spotOptionsHasBeenSet = false;
  bool m_slurmConfigurationHasBeenSet = false;
  bool m_nodeLifecycleActionsHasBeenSet = false;
  bool m_errorInfoHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace PCS
}  // namespace Aws