CreateFleetRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/gamelift/GameLiftRequest.h>
#include <aws/gamelift/GameLift_EXPORTS.h>
#include <aws/gamelift/model/AnywhereConfiguration.h>
#include <aws/gamelift/model/CertificateConfiguration.h>
#include <aws/gamelift/model/ComputeType.h>
#include <aws/gamelift/model/EC2InstanceType.h>
#include <aws/gamelift/model/FleetType.h>
#include <aws/gamelift/model/InstanceRoleCredentialsProvider.h>
#include <aws/gamelift/model/IpPermission.h>
#include <aws/gamelift/model/LocationConfiguration.h>
#include <aws/gamelift/model/ProtectionPolicy.h>
#include <aws/gamelift/model/ResourceCreationLimitPolicy.h>
#include <aws/gamelift/model/RuntimeConfiguration.h>
#include <aws/gamelift/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace GameLift {
namespace Model {
 
class CreateFleetRequest : public GameLiftRequest {
 public:
  AWS_GAMELIFT_API CreateFleetRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CreateFleet"; }
 
  AWS_GAMELIFT_API Aws::String SerializePayload() const override;
 
  AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
  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>
  CreateFleetRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  CreateFleetRequest& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBuildId() const { return m_buildId; }
  inline bool BuildIdHasBeenSet() const { return m_buildIdHasBeenSet; }
  template <typename BuildIdT = Aws::String>
  void SetBuildId(BuildIdT&& value) {
    m_buildIdHasBeenSet = true;
    m_buildId = std::forward<BuildIdT>(value);
  }
  template <typename BuildIdT = Aws::String>
  CreateFleetRequest& WithBuildId(BuildIdT&& value) {
    SetBuildId(std::forward<BuildIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetScriptId() const { return m_scriptId; }
  inline bool ScriptIdHasBeenSet() const { return m_scriptIdHasBeenSet; }
  template <typename ScriptIdT = Aws::String>
  void SetScriptId(ScriptIdT&& value) {
    m_scriptIdHasBeenSet = true;
    m_scriptId = std::forward<ScriptIdT>(value);
  }
  template <typename ScriptIdT = Aws::String>
  CreateFleetRequest& WithScriptId(ScriptIdT&& value) {
    SetScriptId(std::forward<ScriptIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServerLaunchPath() const { return m_serverLaunchPath; }
  inline bool ServerLaunchPathHasBeenSet() const { return m_serverLaunchPathHasBeenSet; }
  template <typename ServerLaunchPathT = Aws::String>
  void SetServerLaunchPath(ServerLaunchPathT&& value) {
    m_serverLaunchPathHasBeenSet = true;
    m_serverLaunchPath = std::forward<ServerLaunchPathT>(value);
  }
  template <typename ServerLaunchPathT = Aws::String>
  CreateFleetRequest& WithServerLaunchPath(ServerLaunchPathT&& value) {
    SetServerLaunchPath(std::forward<ServerLaunchPathT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServerLaunchParameters() const { return m_serverLaunchParameters; }
  inline bool ServerLaunchParametersHasBeenSet() const { return m_serverLaunchParametersHasBeenSet; }
  template <typename ServerLaunchParametersT = Aws::String>
  void SetServerLaunchParameters(ServerLaunchParametersT&& value) {
    m_serverLaunchParametersHasBeenSet = true;
    m_serverLaunchParameters = std::forward<ServerLaunchParametersT>(value);
  }
  template <typename ServerLaunchParametersT = Aws::String>
  CreateFleetRequest& WithServerLaunchParameters(ServerLaunchParametersT&& value) {
    SetServerLaunchParameters(std::forward<ServerLaunchParametersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetLogPaths() const { return m_logPaths; }
  inline bool LogPathsHasBeenSet() const { return m_logPathsHasBeenSet; }
  template <typename LogPathsT = Aws::Vector<Aws::String>>
  void SetLogPaths(LogPathsT&& value) {
    m_logPathsHasBeenSet = true;
    m_logPaths = std::forward<LogPathsT>(value);
  }
  template <typename LogPathsT = Aws::Vector<Aws::String>>
  CreateFleetRequest& WithLogPaths(LogPathsT&& value) {
    SetLogPaths(std::forward<LogPathsT>(value));
    return *this;
  }
  template <typename LogPathsT = Aws::String>
  CreateFleetRequest& AddLogPaths(LogPathsT&& value) {
    m_logPathsHasBeenSet = true;
    m_logPaths.emplace_back(std::forward<LogPathsT>(value));
    return *this;
  }
 
 
  inline EC2InstanceType GetEC2InstanceType() const { return m_eC2InstanceType; }
  inline bool EC2InstanceTypeHasBeenSet() const { return m_eC2InstanceTypeHasBeenSet; }
  inline void SetEC2InstanceType(EC2InstanceType value) {
    m_eC2InstanceTypeHasBeenSet = true;
    m_eC2InstanceType = value;
  }
  inline CreateFleetRequest& WithEC2InstanceType(EC2InstanceType value) {
    SetEC2InstanceType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<IpPermission>& GetEC2InboundPermissions() const { return m_eC2InboundPermissions; }
  inline bool EC2InboundPermissionsHasBeenSet() const { return m_eC2InboundPermissionsHasBeenSet; }
  template <typename EC2InboundPermissionsT = Aws::Vector<IpPermission>>
  void SetEC2InboundPermissions(EC2InboundPermissionsT&& value) {
    m_eC2InboundPermissionsHasBeenSet = true;
    m_eC2InboundPermissions = std::forward<EC2InboundPermissionsT>(value);
  }
  template <typename EC2InboundPermissionsT = Aws::Vector<IpPermission>>
  CreateFleetRequest& WithEC2InboundPermissions(EC2InboundPermissionsT&& value) {
    SetEC2InboundPermissions(std::forward<EC2InboundPermissionsT>(value));
    return *this;
  }
  template <typename EC2InboundPermissionsT = IpPermission>
  CreateFleetRequest& AddEC2InboundPermissions(EC2InboundPermissionsT&& value) {
    m_eC2InboundPermissionsHasBeenSet = true;
    m_eC2InboundPermissions.emplace_back(std::forward<EC2InboundPermissionsT>(value));
    return *this;
  }
 
 
  inline ProtectionPolicy GetNewGameSessionProtectionPolicy() const { return m_newGameSessionProtectionPolicy; }
  inline bool NewGameSessionProtectionPolicyHasBeenSet() const { return m_newGameSessionProtectionPolicyHasBeenSet; }
  inline void SetNewGameSessionProtectionPolicy(ProtectionPolicy value) {
    m_newGameSessionProtectionPolicyHasBeenSet = true;
    m_newGameSessionProtectionPolicy = value;
  }
  inline CreateFleetRequest& WithNewGameSessionProtectionPolicy(ProtectionPolicy value) {
    SetNewGameSessionProtectionPolicy(value);
    return *this;
  }
 
 
  inline const RuntimeConfiguration& GetRuntimeConfiguration() const { return m_runtimeConfiguration; }
  inline bool RuntimeConfigurationHasBeenSet() const { return m_runtimeConfigurationHasBeenSet; }
  template <typename RuntimeConfigurationT = RuntimeConfiguration>
  void SetRuntimeConfiguration(RuntimeConfigurationT&& value) {
    m_runtimeConfigurationHasBeenSet = true;
    m_runtimeConfiguration = std::forward<RuntimeConfigurationT>(value);
  }
  template <typename RuntimeConfigurationT = RuntimeConfiguration>
  CreateFleetRequest& WithRuntimeConfiguration(RuntimeConfigurationT&& value) {
    SetRuntimeConfiguration(std::forward<RuntimeConfigurationT>(value));
    return *this;
  }
 
 
  inline const ResourceCreationLimitPolicy& GetResourceCreationLimitPolicy() const { return m_resourceCreationLimitPolicy; }
  inline bool ResourceCreationLimitPolicyHasBeenSet() const { return m_resourceCreationLimitPolicyHasBeenSet; }
  template <typename ResourceCreationLimitPolicyT = ResourceCreationLimitPolicy>
  void SetResourceCreationLimitPolicy(ResourceCreationLimitPolicyT&& value) {
    m_resourceCreationLimitPolicyHasBeenSet = true;
    m_resourceCreationLimitPolicy = std::forward<ResourceCreationLimitPolicyT>(value);
  }
  template <typename ResourceCreationLimitPolicyT = ResourceCreationLimitPolicy>
  CreateFleetRequest& WithResourceCreationLimitPolicy(ResourceCreationLimitPolicyT&& value) {
    SetResourceCreationLimitPolicy(std::forward<ResourceCreationLimitPolicyT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetMetricGroups() const { return m_metricGroups; }
  inline bool MetricGroupsHasBeenSet() const { return m_metricGroupsHasBeenSet; }
  template <typename MetricGroupsT = Aws::Vector<Aws::String>>
  void SetMetricGroups(MetricGroupsT&& value) {
    m_metricGroupsHasBeenSet = true;
    m_metricGroups = std::forward<MetricGroupsT>(value);
  }
  template <typename MetricGroupsT = Aws::Vector<Aws::String>>
  CreateFleetRequest& WithMetricGroups(MetricGroupsT&& value) {
    SetMetricGroups(std::forward<MetricGroupsT>(value));
    return *this;
  }
  template <typename MetricGroupsT = Aws::String>
  CreateFleetRequest& AddMetricGroups(MetricGroupsT&& value) {
    m_metricGroupsHasBeenSet = true;
    m_metricGroups.emplace_back(std::forward<MetricGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPeerVpcAwsAccountId() const { return m_peerVpcAwsAccountId; }
  inline bool PeerVpcAwsAccountIdHasBeenSet() const { return m_peerVpcAwsAccountIdHasBeenSet; }
  template <typename PeerVpcAwsAccountIdT = Aws::String>
  void SetPeerVpcAwsAccountId(PeerVpcAwsAccountIdT&& value) {
    m_peerVpcAwsAccountIdHasBeenSet = true;
    m_peerVpcAwsAccountId = std::forward<PeerVpcAwsAccountIdT>(value);
  }
  template <typename PeerVpcAwsAccountIdT = Aws::String>
  CreateFleetRequest& WithPeerVpcAwsAccountId(PeerVpcAwsAccountIdT&& value) {
    SetPeerVpcAwsAccountId(std::forward<PeerVpcAwsAccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPeerVpcId() const { return m_peerVpcId; }
  inline bool PeerVpcIdHasBeenSet() const { return m_peerVpcIdHasBeenSet; }
  template <typename PeerVpcIdT = Aws::String>
  void SetPeerVpcId(PeerVpcIdT&& value) {
    m_peerVpcIdHasBeenSet = true;
    m_peerVpcId = std::forward<PeerVpcIdT>(value);
  }
  template <typename PeerVpcIdT = Aws::String>
  CreateFleetRequest& WithPeerVpcId(PeerVpcIdT&& value) {
    SetPeerVpcId(std::forward<PeerVpcIdT>(value));
    return *this;
  }
 
 
  inline FleetType GetFleetType() const { return m_fleetType; }
  inline bool FleetTypeHasBeenSet() const { return m_fleetTypeHasBeenSet; }
  inline void SetFleetType(FleetType value) {
    m_fleetTypeHasBeenSet = true;
    m_fleetType = value;
  }
  inline CreateFleetRequest& WithFleetType(FleetType value) {
    SetFleetType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceRoleArn() const { return m_instanceRoleArn; }
  inline bool InstanceRoleArnHasBeenSet() const { return m_instanceRoleArnHasBeenSet; }
  template <typename InstanceRoleArnT = Aws::String>
  void SetInstanceRoleArn(InstanceRoleArnT&& value) {
    m_instanceRoleArnHasBeenSet = true;
    m_instanceRoleArn = std::forward<InstanceRoleArnT>(value);
  }
  template <typename InstanceRoleArnT = Aws::String>
  CreateFleetRequest& WithInstanceRoleArn(InstanceRoleArnT&& value) {
    SetInstanceRoleArn(std::forward<InstanceRoleArnT>(value));
    return *this;
  }
 
 
  inline const CertificateConfiguration& GetCertificateConfiguration() const { return m_certificateConfiguration; }
  inline bool CertificateConfigurationHasBeenSet() const { return m_certificateConfigurationHasBeenSet; }
  template <typename CertificateConfigurationT = CertificateConfiguration>
  void SetCertificateConfiguration(CertificateConfigurationT&& value) {
    m_certificateConfigurationHasBeenSet = true;
    m_certificateConfiguration = std::forward<CertificateConfigurationT>(value);
  }
  template <typename CertificateConfigurationT = CertificateConfiguration>
  CreateFleetRequest& WithCertificateConfiguration(CertificateConfigurationT&& value) {
    SetCertificateConfiguration(std::forward<CertificateConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LocationConfiguration>& GetLocations() const { return m_locations; }
  inline bool LocationsHasBeenSet() const { return m_locationsHasBeenSet; }
  template <typename LocationsT = Aws::Vector<LocationConfiguration>>
  void SetLocations(LocationsT&& value) {
    m_locationsHasBeenSet = true;
    m_locations = std::forward<LocationsT>(value);
  }
  template <typename LocationsT = Aws::Vector<LocationConfiguration>>
  CreateFleetRequest& WithLocations(LocationsT&& value) {
    SetLocations(std::forward<LocationsT>(value));
    return *this;
  }
  template <typename LocationsT = LocationConfiguration>
  CreateFleetRequest& AddLocations(LocationsT&& value) {
    m_locationsHasBeenSet = true;
    m_locations.emplace_back(std::forward<LocationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CreateFleetRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateFleetRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline ComputeType GetComputeType() const { return m_computeType; }
  inline bool ComputeTypeHasBeenSet() const { return m_computeTypeHasBeenSet; }
  inline void SetComputeType(ComputeType value) {
    m_computeTypeHasBeenSet = true;
    m_computeType = value;
  }
  inline CreateFleetRequest& WithComputeType(ComputeType value) {
    SetComputeType(value);
    return *this;
  }
 
 
  inline const AnywhereConfiguration& GetAnywhereConfiguration() const { return m_anywhereConfiguration; }
  inline bool AnywhereConfigurationHasBeenSet() const { return m_anywhereConfigurationHasBeenSet; }
  template <typename AnywhereConfigurationT = AnywhereConfiguration>
  void SetAnywhereConfiguration(AnywhereConfigurationT&& value) {
    m_anywhereConfigurationHasBeenSet = true;
    m_anywhereConfiguration = std::forward<AnywhereConfigurationT>(value);
  }
  template <typename AnywhereConfigurationT = AnywhereConfiguration>
  CreateFleetRequest& WithAnywhereConfiguration(AnywhereConfigurationT&& value) {
    SetAnywhereConfiguration(std::forward<AnywhereConfigurationT>(value));
    return *this;
  }
 
 
  inline InstanceRoleCredentialsProvider GetInstanceRoleCredentialsProvider() const { return m_instanceRoleCredentialsProvider; }
  inline bool InstanceRoleCredentialsProviderHasBeenSet() const { return m_instanceRoleCredentialsProviderHasBeenSet; }
  inline void SetInstanceRoleCredentialsProvider(InstanceRoleCredentialsProvider value) {
    m_instanceRoleCredentialsProviderHasBeenSet = true;
    m_instanceRoleCredentialsProvider = value;
  }
  inline CreateFleetRequest& WithInstanceRoleCredentialsProvider(InstanceRoleCredentialsProvider value) {
    SetInstanceRoleCredentialsProvider(value);
    return *this;
  }
 private:
  Aws::String m_name;
 
  Aws::String m_description;
 
  Aws::String m_buildId;
 
  Aws::String m_scriptId;
 
  Aws::String m_serverLaunchPath;
 
  Aws::String m_serverLaunchParameters;
 
  Aws::Vector<Aws::String> m_logPaths;
 
  EC2InstanceType m_eC2InstanceType{EC2InstanceType::NOT_SET};
 
  Aws::Vector<IpPermission> m_eC2InboundPermissions;
 
  ProtectionPolicy m_newGameSessionProtectionPolicy{ProtectionPolicy::NOT_SET};
 
  RuntimeConfiguration m_runtimeConfiguration;
 
  ResourceCreationLimitPolicy m_resourceCreationLimitPolicy;
 
  Aws::Vector<Aws::String> m_metricGroups;
 
  Aws::String m_peerVpcAwsAccountId;
 
  Aws::String m_peerVpcId;
 
  FleetType m_fleetType{FleetType::NOT_SET};
 
  Aws::String m_instanceRoleArn;
 
  CertificateConfiguration m_certificateConfiguration;
 
  Aws::Vector<LocationConfiguration> m_locations;
 
  Aws::Vector<Tag> m_tags;
 
  ComputeType m_computeType{ComputeType::NOT_SET};
 
  AnywhereConfiguration m_anywhereConfiguration;
 
  InstanceRoleCredentialsProvider m_instanceRoleCredentialsProvider{InstanceRoleCredentialsProvider::NOT_SET};
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_buildIdHasBeenSet = false;
  bool m_scriptIdHasBeenSet = false;
  bool m_serverLaunchPathHasBeenSet = false;
  bool m_serverLaunchParametersHasBeenSet = false;
  bool m_logPathsHasBeenSet = false;
  bool m_eC2InstanceTypeHasBeenSet = false;
  bool m_eC2InboundPermissionsHasBeenSet = false;
  bool m_newGameSessionProtectionPolicyHasBeenSet = false;
  bool m_runtimeConfigurationHasBeenSet = false;
  bool m_resourceCreationLimitPolicyHasBeenSet = false;
  bool m_metricGroupsHasBeenSet = false;
  bool m_peerVpcAwsAccountIdHasBeenSet = false;
  bool m_peerVpcIdHasBeenSet = false;
  bool m_fleetTypeHasBeenSet = false;
  bool m_instanceRoleArnHasBeenSet = false;
  bool m_certificateConfigurationHasBeenSet = false;
  bool m_locationsHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_computeTypeHasBeenSet = false;
  bool m_anywhereConfigurationHasBeenSet = false;
  bool m_instanceRoleCredentialsProviderHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace GameLift
}  // namespace Aws