ComputeResource.h

 
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/batch/model/CRType.h>
#include <aws/batch/model/CRAllocationStrategy.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/batch/model/LaunchTemplateSpecification.h>
#include <aws/batch/model/Ec2Configuration.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; }
  private:
 
    CRType m_type{CRType::NOT_SET};
    bool m_typeHasBeenSet = false;
 
    CRAllocationStrategy m_allocationStrategy{CRAllocationStrategy::NOT_SET};
    bool m_allocationStrategyHasBeenSet = false;
 
    int m_minvCpus{0};
    bool m_minvCpusHasBeenSet = false;
 
    int m_maxvCpus{0};
    bool m_maxvCpusHasBeenSet = false;
 
    int m_desiredvCpus{0};
    bool m_desiredvCpusHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_instanceTypes;
    bool m_instanceTypesHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_subnets;
    bool m_subnetsHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_securityGroupIds;
    bool m_securityGroupIdsHasBeenSet = false;
 
    Aws::String m_ec2KeyPair;
    bool m_ec2KeyPairHasBeenSet = false;
 
    Aws::String m_instanceRole;
    bool m_instanceRoleHasBeenSet = false;
 
    Aws::Map<Aws::String, Aws::String> m_tags;
    bool m_tagsHasBeenSet = false;
 
    Aws::String m_placementGroup;
    bool m_placementGroupHasBeenSet = false;
 
    int m_bidPercentage{0};
    bool m_bidPercentageHasBeenSet = false;
 
    Aws::String m_spotIamFleetRole;
    bool m_spotIamFleetRoleHasBeenSet = false;
 
    LaunchTemplateSpecification m_launchTemplate;
    bool m_launchTemplateHasBeenSet = false;
 
    Aws::Vector<Ec2Configuration> m_ec2Configuration;
    bool m_ec2ConfigurationHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Batch
} // namespace Aws