ComputeResource.h

 
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/batch/model/CRAllocationStrategy.h>
#include <aws/batch/model/CRType.h>
#include <aws/batch/model/ComputeScalingPolicy.h>
#include <aws/batch/model/Ec2Configuration.h>
#include <aws/batch/model/LaunchTemplateSpecification.h>
#include <aws/batch/model/ManagedInstancesProvider.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Batch {
namespace Model {
 
class ComputeResource {
 public:
  AWS_BATCH_API ComputeResource() = default;
  AWS_BATCH_API ComputeResource(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API ComputeResource& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline CRType GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(CRType value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline ComputeResource& WithType(CRType value) {
    SetType(value);
    return *this;
  }
 
 
  inline CRAllocationStrategy GetAllocationStrategy() const { return m_allocationStrategy; }
  inline bool AllocationStrategyHasBeenSet() const { return m_allocationStrategyHasBeenSet; }
  inline void SetAllocationStrategy(CRAllocationStrategy value) {
    m_allocationStrategyHasBeenSet = true;
    m_allocationStrategy = value;
  }
  inline ComputeResource& WithAllocationStrategy(CRAllocationStrategy value) {
    SetAllocationStrategy(value);
    return *this;
  }
 
 
  inline int GetMinvCpus() const { return m_minvCpus; }
  inline bool MinvCpusHasBeenSet() const { return m_minvCpusHasBeenSet; }
  inline void SetMinvCpus(int value) {
    m_minvCpusHasBeenSet = true;
    m_minvCpus = value;
  }
  inline ComputeResource& WithMinvCpus(int value) {
    SetMinvCpus(value);
    return *this;
  }
 
 
  inline int GetMaxvCpus() const { return m_maxvCpus; }
  inline bool MaxvCpusHasBeenSet() const { return m_maxvCpusHasBeenSet; }
  inline void SetMaxvCpus(int value) {
    m_maxvCpusHasBeenSet = true;
    m_maxvCpus = value;
  }
  inline ComputeResource& WithMaxvCpus(int value) {
    SetMaxvCpus(value);
    return *this;
  }
 
 
  inline int GetDesiredvCpus() const { return m_desiredvCpus; }
  inline bool DesiredvCpusHasBeenSet() const { return m_desiredvCpusHasBeenSet; }
  inline void SetDesiredvCpus(int value) {
    m_desiredvCpusHasBeenSet = true;
    m_desiredvCpus = value;
  }
  inline ComputeResource& WithDesiredvCpus(int value) {
    SetDesiredvCpus(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetInstanceTypes() const { return m_instanceTypes; }
  inline bool InstanceTypesHasBeenSet() const { return m_instanceTypesHasBeenSet; }
  template <typename InstanceTypesT = Aws::Vector<Aws::String>>
  void SetInstanceTypes(InstanceTypesT&& value) {
    m_instanceTypesHasBeenSet = true;
    m_instanceTypes = std::forward<InstanceTypesT>(value);
  }
  template <typename InstanceTypesT = Aws::Vector<Aws::String>>
  ComputeResource& WithInstanceTypes(InstanceTypesT&& value) {
    SetInstanceTypes(std::forward<InstanceTypesT>(value));
    return *this;
  }
  template <typename InstanceTypesT = Aws::String>
  ComputeResource& AddInstanceTypes(InstanceTypesT&& value) {
    m_instanceTypesHasBeenSet = true;
    m_instanceTypes.emplace_back(std::forward<InstanceTypesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSubnets() const { return m_subnets; }
  inline bool SubnetsHasBeenSet() const { return m_subnetsHasBeenSet; }
  template <typename SubnetsT = Aws::Vector<Aws::String>>
  void SetSubnets(SubnetsT&& value) {
    m_subnetsHasBeenSet = true;
    m_subnets = std::forward<SubnetsT>(value);
  }
  template <typename SubnetsT = Aws::Vector<Aws::String>>
  ComputeResource& WithSubnets(SubnetsT&& value) {
    SetSubnets(std::forward<SubnetsT>(value));
    return *this;
  }
  template <typename SubnetsT = Aws::String>
  ComputeResource& AddSubnets(SubnetsT&& value) {
    m_subnetsHasBeenSet = true;
    m_subnets.emplace_back(std::forward<SubnetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const { return m_securityGroupIds; }
  inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
  template <typename SecurityGroupIdsT = Aws::Vector<Aws::String>>
  void SetSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds = std::forward<SecurityGroupIdsT>(value);
  }
  template <typename SecurityGroupIdsT = Aws::Vector<Aws::String>>
  ComputeResource& WithSecurityGroupIds(SecurityGroupIdsT&& value) {
    SetSecurityGroupIds(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
  template <typename SecurityGroupIdsT = Aws::String>
  ComputeResource& AddSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds.emplace_back(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEc2KeyPair() const { return m_ec2KeyPair; }
  inline bool Ec2KeyPairHasBeenSet() const { return m_ec2KeyPairHasBeenSet; }
  template <typename Ec2KeyPairT = Aws::String>
  void SetEc2KeyPair(Ec2KeyPairT&& value) {
    m_ec2KeyPairHasBeenSet = true;
    m_ec2KeyPair = std::forward<Ec2KeyPairT>(value);
  }
  template <typename Ec2KeyPairT = Aws::String>
  ComputeResource& WithEc2KeyPair(Ec2KeyPairT&& value) {
    SetEc2KeyPair(std::forward<Ec2KeyPairT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceRole() const { return m_instanceRole; }
  inline bool InstanceRoleHasBeenSet() const { return m_instanceRoleHasBeenSet; }
  template <typename InstanceRoleT = Aws::String>
  void SetInstanceRole(InstanceRoleT&& value) {
    m_instanceRoleHasBeenSet = true;
    m_instanceRole = std::forward<InstanceRoleT>(value);
  }
  template <typename InstanceRoleT = Aws::String>
  ComputeResource& WithInstanceRole(InstanceRoleT&& value) {
    SetInstanceRole(std::forward<InstanceRoleT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  ComputeResource& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  ComputeResource& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPlacementGroup() const { return m_placementGroup; }
  inline bool PlacementGroupHasBeenSet() const { return m_placementGroupHasBeenSet; }
  template <typename PlacementGroupT = Aws::String>
  void SetPlacementGroup(PlacementGroupT&& value) {
    m_placementGroupHasBeenSet = true;
    m_placementGroup = std::forward<PlacementGroupT>(value);
  }
  template <typename PlacementGroupT = Aws::String>
  ComputeResource& WithPlacementGroup(PlacementGroupT&& value) {
    SetPlacementGroup(std::forward<PlacementGroupT>(value));
    return *this;
  }
 
 
  inline int GetBidPercentage() const { return m_bidPercentage; }
  inline bool BidPercentageHasBeenSet() const { return m_bidPercentageHasBeenSet; }
  inline void SetBidPercentage(int value) {
    m_bidPercentageHasBeenSet = true;
    m_bidPercentage = value;
  }
  inline ComputeResource& WithBidPercentage(int value) {
    SetBidPercentage(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSpotIamFleetRole() const { return m_spotIamFleetRole; }
  inline bool SpotIamFleetRoleHasBeenSet() const { return m_spotIamFleetRoleHasBeenSet; }
  template <typename SpotIamFleetRoleT = Aws::String>
  void SetSpotIamFleetRole(SpotIamFleetRoleT&& value) {
    m_spotIamFleetRoleHasBeenSet = true;
    m_spotIamFleetRole = std::forward<SpotIamFleetRoleT>(value);
  }
  template <typename SpotIamFleetRoleT = Aws::String>
  ComputeResource& WithSpotIamFleetRole(SpotIamFleetRoleT&& value) {
    SetSpotIamFleetRole(std::forward<SpotIamFleetRoleT>(value));
    return *this;
  }
 
 
  inline const LaunchTemplateSpecification& GetLaunchTemplate() const { return m_launchTemplate; }
  inline bool LaunchTemplateHasBeenSet() const { return m_launchTemplateHasBeenSet; }
  template <typename LaunchTemplateT = LaunchTemplateSpecification>
  void SetLaunchTemplate(LaunchTemplateT&& value) {
    m_launchTemplateHasBeenSet = true;
    m_launchTemplate = std::forward<LaunchTemplateT>(value);
  }
  template <typename LaunchTemplateT = LaunchTemplateSpecification>
  ComputeResource& WithLaunchTemplate(LaunchTemplateT&& value) {
    SetLaunchTemplate(std::forward<LaunchTemplateT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Ec2Configuration>& GetEc2Configuration() const { return m_ec2Configuration; }
  inline bool Ec2ConfigurationHasBeenSet() const { return m_ec2ConfigurationHasBeenSet; }
  template <typename Ec2ConfigurationT = Aws::Vector<Ec2Configuration>>
  void SetEc2Configuration(Ec2ConfigurationT&& value) {
    m_ec2ConfigurationHasBeenSet = true;
    m_ec2Configuration = std::forward<Ec2ConfigurationT>(value);
  }
  template <typename Ec2ConfigurationT = Aws::Vector<Ec2Configuration>>
  ComputeResource& WithEc2Configuration(Ec2ConfigurationT&& value) {
    SetEc2Configuration(std::forward<Ec2ConfigurationT>(value));
    return *this;
  }
  template <typename Ec2ConfigurationT = Ec2Configuration>
  ComputeResource& AddEc2Configuration(Ec2ConfigurationT&& value) {
    m_ec2ConfigurationHasBeenSet = true;
    m_ec2Configuration.emplace_back(std::forward<Ec2ConfigurationT>(value));
    return *this;
  }
 
 
  inline const ComputeScalingPolicy& GetScalingPolicy() const { return m_scalingPolicy; }
  inline bool ScalingPolicyHasBeenSet() const { return m_scalingPolicyHasBeenSet; }
  template <typename ScalingPolicyT = ComputeScalingPolicy>
  void SetScalingPolicy(ScalingPolicyT&& value) {
    m_scalingPolicyHasBeenSet = true;
    m_scalingPolicy = std::forward<ScalingPolicyT>(value);
  }
  template <typename ScalingPolicyT = ComputeScalingPolicy>
  ComputeResource& WithScalingPolicy(ScalingPolicyT&& value) {
    SetScalingPolicy(std::forward<ScalingPolicyT>(value));
    return *this;
  }
 
 
  inline const ManagedInstancesProvider& GetManagedInstancesProvider() const { return m_managedInstancesProvider; }
  inline bool ManagedInstancesProviderHasBeenSet() const { return m_managedInstancesProviderHasBeenSet; }
  template <typename ManagedInstancesProviderT = ManagedInstancesProvider>
  void SetManagedInstancesProvider(ManagedInstancesProviderT&& value) {
    m_managedInstancesProviderHasBeenSet = true;
    m_managedInstancesProvider = std::forward<ManagedInstancesProviderT>(value);
  }
  template <typename ManagedInstancesProviderT = ManagedInstancesProvider>
  ComputeResource& WithManagedInstancesProvider(ManagedInstancesProviderT&& value) {
    SetManagedInstancesProvider(std::forward<ManagedInstancesProviderT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetCapacityTags() const { return m_capacityTags; }
  inline bool CapacityTagsHasBeenSet() const { return m_capacityTagsHasBeenSet; }
  template <typename CapacityTagsT = Aws::Map<Aws::String, Aws::String>>
  void SetCapacityTags(CapacityTagsT&& value) {
    m_capacityTagsHasBeenSet = true;
    m_capacityTags = std::forward<CapacityTagsT>(value);
  }
  template <typename CapacityTagsT = Aws::Map<Aws::String, Aws::String>>
  ComputeResource& WithCapacityTags(CapacityTagsT&& value) {
    SetCapacityTags(std::forward<CapacityTagsT>(value));
    return *this;
  }
  template <typename CapacityTagsKeyT = Aws::String, typename CapacityTagsValueT = Aws::String>
  ComputeResource& AddCapacityTags(CapacityTagsKeyT&& key, CapacityTagsValueT&& value) {
    m_capacityTagsHasBeenSet = true;
    m_capacityTags.emplace(std::forward<CapacityTagsKeyT>(key), std::forward<CapacityTagsValueT>(value));
    return *this;
  }
 private:
  CRType m_type{CRType::NOT_SET};
 
  CRAllocationStrategy m_allocationStrategy{CRAllocationStrategy::NOT_SET};
 
  int m_minvCpus{0};
 
  int m_maxvCpus{0};
 
  int m_desiredvCpus{0};
 
  Aws::Vector<Aws::String> m_instanceTypes;
 
  Aws::Vector<Aws::String> m_subnets;
 
  Aws::Vector<Aws::String> m_securityGroupIds;
 
  Aws::String m_ec2KeyPair;
 
  Aws::String m_instanceRole;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::String m_placementGroup;
 
  int m_bidPercentage{0};
 
  Aws::String m_spotIamFleetRole;
 
  LaunchTemplateSpecification m_launchTemplate;
 
  Aws::Vector<Ec2Configuration> m_ec2Configuration;
 
  ComputeScalingPolicy m_scalingPolicy;
 
  ManagedInstancesProvider m_managedInstancesProvider;
 
  Aws::Map<Aws::String, Aws::String> m_capacityTags;
  bool m_typeHasBeenSet = false;
  bool m_allocationStrategyHasBeenSet = false;
  bool m_minvCpusHasBeenSet = false;
  bool m_maxvCpusHasBeenSet = false;
  bool m_desiredvCpusHasBeenSet = false;
  bool m_instanceTypesHasBeenSet = false;
  bool m_subnetsHasBeenSet = false;
  bool m_securityGroupIdsHasBeenSet = false;
  bool m_ec2KeyPairHasBeenSet = false;
  bool m_instanceRoleHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_placementGroupHasBeenSet = false;
  bool m_bidPercentageHasBeenSet = false;
  bool m_spotIamFleetRoleHasBeenSet = false;
  bool m_launchTemplateHasBeenSet = false;
  bool m_ec2ConfigurationHasBeenSet = false;
  bool m_scalingPolicyHasBeenSet = false;
  bool m_managedInstancesProviderHasBeenSet = false;
  bool m_capacityTagsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Batch
}  // namespace Aws