ComputeResourceUpdate.h

 
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/batch/model/CRType.h>
#include <aws/batch/model/CRUpdateAllocationStrategy.h>
#include <aws/batch/model/Ec2Configuration.h>
#include <aws/batch/model/LaunchTemplateSpecification.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 ComputeResourceUpdate {
 public:
  AWS_BATCH_API ComputeResourceUpdate() = default;
  AWS_BATCH_API ComputeResourceUpdate(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API ComputeResourceUpdate& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  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 ComputeResourceUpdate& 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 ComputeResourceUpdate& 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 ComputeResourceUpdate& WithDesiredvCpus(int value) {
    SetDesiredvCpus(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>>
  ComputeResourceUpdate& WithSubnets(SubnetsT&& value) {
    SetSubnets(std::forward<SubnetsT>(value));
    return *this;
  }
  template <typename SubnetsT = Aws::String>
  ComputeResourceUpdate& 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>>
  ComputeResourceUpdate& WithSecurityGroupIds(SecurityGroupIdsT&& value) {
    SetSecurityGroupIds(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
  template <typename SecurityGroupIdsT = Aws::String>
  ComputeResourceUpdate& AddSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds.emplace_back(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
 
 
  inline CRUpdateAllocationStrategy GetAllocationStrategy() const { return m_allocationStrategy; }
  inline bool AllocationStrategyHasBeenSet() const { return m_allocationStrategyHasBeenSet; }
  inline void SetAllocationStrategy(CRUpdateAllocationStrategy value) {
    m_allocationStrategyHasBeenSet = true;
    m_allocationStrategy = value;
  }
  inline ComputeResourceUpdate& WithAllocationStrategy(CRUpdateAllocationStrategy value) {
    SetAllocationStrategy(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>>
  ComputeResourceUpdate& WithInstanceTypes(InstanceTypesT&& value) {
    SetInstanceTypes(std::forward<InstanceTypesT>(value));
    return *this;
  }
  template <typename InstanceTypesT = Aws::String>
  ComputeResourceUpdate& AddInstanceTypes(InstanceTypesT&& value) {
    m_instanceTypesHasBeenSet = true;
    m_instanceTypes.emplace_back(std::forward<InstanceTypesT>(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>
  ComputeResourceUpdate& 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>
  ComputeResourceUpdate& 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>>
  ComputeResourceUpdate& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  ComputeResourceUpdate& 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>
  ComputeResourceUpdate& 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 ComputeResourceUpdate& WithBidPercentage(int value) {
    SetBidPercentage(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>
  ComputeResourceUpdate& 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>>
  ComputeResourceUpdate& WithEc2Configuration(Ec2ConfigurationT&& value) {
    SetEc2Configuration(std::forward<Ec2ConfigurationT>(value));
    return *this;
  }
  template <typename Ec2ConfigurationT = Ec2Configuration>
  ComputeResourceUpdate& AddEc2Configuration(Ec2ConfigurationT&& value) {
    m_ec2ConfigurationHasBeenSet = true;
    m_ec2Configuration.emplace_back(std::forward<Ec2ConfigurationT>(value));
    return *this;
  }
 
 
  inline bool GetUpdateToLatestImageVersion() const { return m_updateToLatestImageVersion; }
  inline bool UpdateToLatestImageVersionHasBeenSet() const { return m_updateToLatestImageVersionHasBeenSet; }
  inline void SetUpdateToLatestImageVersion(bool value) {
    m_updateToLatestImageVersionHasBeenSet = true;
    m_updateToLatestImageVersion = value;
  }
  inline ComputeResourceUpdate& WithUpdateToLatestImageVersion(bool value) {
    SetUpdateToLatestImageVersion(value);
    return *this;
  }
 
 
  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 ComputeResourceUpdate& WithType(CRType value) {
    SetType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetImageId() const { return m_imageId; }
  inline bool ImageIdHasBeenSet() const { return m_imageIdHasBeenSet; }
  template <typename ImageIdT = Aws::String>
  void SetImageId(ImageIdT&& value) {
    m_imageIdHasBeenSet = true;
    m_imageId = std::forward<ImageIdT>(value);
  }
  template <typename ImageIdT = Aws::String>
  ComputeResourceUpdate& WithImageId(ImageIdT&& value) {
    SetImageId(std::forward<ImageIdT>(value));
    return *this;
  }
 private:
  int m_minvCpus{0};
 
  int m_maxvCpus{0};
 
  int m_desiredvCpus{0};
 
  Aws::Vector<Aws::String> m_subnets;
 
  Aws::Vector<Aws::String> m_securityGroupIds;
 
  CRUpdateAllocationStrategy m_allocationStrategy{CRUpdateAllocationStrategy::NOT_SET};
 
  Aws::Vector<Aws::String> m_instanceTypes;
 
  Aws::String m_ec2KeyPair;
 
  Aws::String m_instanceRole;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::String m_placementGroup;
 
  int m_bidPercentage{0};
 
  LaunchTemplateSpecification m_launchTemplate;
 
  Aws::Vector<Ec2Configuration> m_ec2Configuration;
 
  bool m_updateToLatestImageVersion{false};
 
  CRType m_type{CRType::NOT_SET};
 
  Aws::String m_imageId;
  bool m_minvCpusHasBeenSet = false;
  bool m_maxvCpusHasBeenSet = false;
  bool m_desiredvCpusHasBeenSet = false;
  bool m_subnetsHasBeenSet = false;
  bool m_securityGroupIdsHasBeenSet = false;
  bool m_allocationStrategyHasBeenSet = false;
  bool m_instanceTypesHasBeenSet = false;
  bool m_ec2KeyPairHasBeenSet = false;
  bool m_instanceRoleHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_placementGroupHasBeenSet = false;
  bool m_bidPercentageHasBeenSet = false;
  bool m_launchTemplateHasBeenSet = false;
  bool m_ec2ConfigurationHasBeenSet = false;
  bool m_updateToLatestImageVersionHasBeenSet = false;
  bool m_typeHasBeenSet = false;
  bool m_imageIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Batch
}  // namespace Aws