Lesson 35 - Get Compute Auth Token Working
This commit is contained in:
Norman Lansing
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/client/GenericClientConfiguration.h>
|
||||
#include <aws/core/endpoint/DefaultEndpointProvider.h>
|
||||
#include <aws/core/endpoint/EndpointParameter.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
|
||||
#include <aws/gamelift/GameLiftEndpointRules.h>
|
||||
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Endpoint
|
||||
{
|
||||
using EndpointParameters = Aws::Endpoint::EndpointParameters;
|
||||
using Aws::Endpoint::EndpointProviderBase;
|
||||
using Aws::Endpoint::DefaultEndpointProvider;
|
||||
|
||||
using GameLiftClientContextParameters = Aws::Endpoint::ClientContextParameters;
|
||||
|
||||
using GameLiftClientConfiguration = Aws::Client::GenericClientConfiguration;
|
||||
using GameLiftBuiltInParameters = Aws::Endpoint::BuiltInParameters;
|
||||
|
||||
/**
|
||||
* The type for the GameLift Client Endpoint Provider.
|
||||
* Inherit from this Base class / "Interface" should you want to provide a custom endpoint provider.
|
||||
* The SDK must use service-specific type for each service per specification.
|
||||
*/
|
||||
using GameLiftEndpointProviderBase =
|
||||
EndpointProviderBase<GameLiftClientConfiguration, GameLiftBuiltInParameters, GameLiftClientContextParameters>;
|
||||
|
||||
using GameLiftDefaultEpProviderBase =
|
||||
DefaultEndpointProvider<GameLiftClientConfiguration, GameLiftBuiltInParameters, GameLiftClientContextParameters>;
|
||||
|
||||
/**
|
||||
* Default endpoint provider used for this service
|
||||
*/
|
||||
class AWS_GAMELIFT_API GameLiftEndpointProvider : public GameLiftDefaultEpProviderBase
|
||||
{
|
||||
public:
|
||||
using GameLiftResolveEndpointOutcome = Aws::Endpoint::ResolveEndpointOutcome;
|
||||
|
||||
GameLiftEndpointProvider()
|
||||
: GameLiftDefaultEpProviderBase(Aws::GameLift::GameLiftEndpointRules::GetRulesBlob(), Aws::GameLift::GameLiftEndpointRules::RulesBlobSize)
|
||||
{}
|
||||
|
||||
~GameLiftEndpointProvider()
|
||||
{
|
||||
}
|
||||
};
|
||||
} // namespace Endpoint
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,23 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
class GameLiftEndpointRules
|
||||
{
|
||||
public:
|
||||
static const size_t RulesBlobStrLen;
|
||||
static const size_t RulesBlobSize;
|
||||
|
||||
static const char* GetRulesBlob();
|
||||
};
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,23 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/client/AWSErrorMarshaller.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Client
|
||||
{
|
||||
|
||||
class AWS_GAMELIFT_API GameLiftErrorMarshaller : public Aws::Client::JsonErrorMarshaller
|
||||
{
|
||||
public:
|
||||
Aws::Client::AWSError<Aws::Client::CoreErrors> FindErrorByName(const char* exceptionName) const override;
|
||||
};
|
||||
|
||||
} // namespace Client
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <aws/core/client/AWSError.h>
|
||||
#include <aws/core/client/CoreErrors.h>
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
enum class GameLiftErrors
|
||||
{
|
||||
//From Core//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////
|
||||
INCOMPLETE_SIGNATURE = 0,
|
||||
INTERNAL_FAILURE = 1,
|
||||
INVALID_ACTION = 2,
|
||||
INVALID_CLIENT_TOKEN_ID = 3,
|
||||
INVALID_PARAMETER_COMBINATION = 4,
|
||||
INVALID_QUERY_PARAMETER = 5,
|
||||
INVALID_PARAMETER_VALUE = 6,
|
||||
MISSING_ACTION = 7, // SDK should never allow
|
||||
MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
|
||||
MISSING_PARAMETER = 9, // SDK should never allow
|
||||
OPT_IN_REQUIRED = 10,
|
||||
REQUEST_EXPIRED = 11,
|
||||
SERVICE_UNAVAILABLE = 12,
|
||||
THROTTLING = 13,
|
||||
VALIDATION = 14,
|
||||
ACCESS_DENIED = 15,
|
||||
RESOURCE_NOT_FOUND = 16,
|
||||
UNRECOGNIZED_CLIENT = 17,
|
||||
MALFORMED_QUERY_STRING = 18,
|
||||
SLOW_DOWN = 19,
|
||||
REQUEST_TIME_TOO_SKEWED = 20,
|
||||
INVALID_SIGNATURE = 21,
|
||||
SIGNATURE_DOES_NOT_MATCH = 22,
|
||||
INVALID_ACCESS_KEY_ID = 23,
|
||||
REQUEST_TIMEOUT = 24,
|
||||
NETWORK_CONNECTION = 99,
|
||||
|
||||
UNKNOWN = 100,
|
||||
///////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
CONFLICT= static_cast<int>(Aws::Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
|
||||
FLEET_CAPACITY_EXCEEDED,
|
||||
GAME_SESSION_FULL,
|
||||
IDEMPOTENT_PARAMETER_MISMATCH,
|
||||
INTERNAL_SERVICE,
|
||||
INVALID_FLEET_STATUS,
|
||||
INVALID_GAME_SESSION_STATUS,
|
||||
INVALID_REQUEST,
|
||||
LIMIT_EXCEEDED,
|
||||
NOT_FOUND,
|
||||
NOT_READY,
|
||||
OUT_OF_CAPACITY,
|
||||
TAGGING_FAILED,
|
||||
TERMINAL_ROUTING_STRATEGY,
|
||||
UNAUTHORIZED,
|
||||
UNSUPPORTED_REGION
|
||||
};
|
||||
|
||||
class AWS_GAMELIFT_API GameLiftError : public Aws::Client::AWSError<GameLiftErrors>
|
||||
{
|
||||
public:
|
||||
GameLiftError() {}
|
||||
GameLiftError(const Aws::Client::AWSError<Aws::Client::CoreErrors>& rhs) : Aws::Client::AWSError<GameLiftErrors>(rhs) {}
|
||||
GameLiftError(Aws::Client::AWSError<Aws::Client::CoreErrors>&& rhs) : Aws::Client::AWSError<GameLiftErrors>(rhs) {}
|
||||
GameLiftError(const Aws::Client::AWSError<GameLiftErrors>& rhs) : Aws::Client::AWSError<GameLiftErrors>(rhs) {}
|
||||
GameLiftError(Aws::Client::AWSError<GameLiftErrors>&& rhs) : Aws::Client::AWSError<GameLiftErrors>(rhs) {}
|
||||
|
||||
template <typename T>
|
||||
T GetModeledError();
|
||||
};
|
||||
|
||||
namespace GameLiftErrorMapper
|
||||
{
|
||||
AWS_GAMELIFT_API Aws::Client::AWSError<Aws::Client::CoreErrors> GetErrorForName(const char* errorName);
|
||||
}
|
||||
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/endpoint/AWSEndpoint.h>
|
||||
#include <aws/core/AmazonSerializableWebServiceRequest.h>
|
||||
#include <aws/core/utils/UnreferencedParam.h>
|
||||
#include <aws/core/http/HttpRequest.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
class AWS_GAMELIFT_API GameLiftRequest : public Aws::AmazonSerializableWebServiceRequest
|
||||
{
|
||||
public:
|
||||
using EndpointParameter = Aws::Endpoint::EndpointParameter;
|
||||
using EndpointParameters = Aws::Endpoint::EndpointParameters;
|
||||
|
||||
virtual ~GameLiftRequest () {}
|
||||
|
||||
void AddParametersToRequest(Aws::Http::HttpRequest& httpRequest) const { AWS_UNREFERENCED_PARAM(httpRequest); }
|
||||
|
||||
inline Aws::Http::HeaderValueCollection GetHeaders() const override
|
||||
{
|
||||
auto headers = GetRequestSpecificHeaders();
|
||||
|
||||
if(headers.size() == 0 || (headers.size() > 0 && headers.count(Aws::Http::CONTENT_TYPE_HEADER) == 0))
|
||||
{
|
||||
headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::CONTENT_TYPE_HEADER, Aws::AMZN_JSON_CONTENT_TYPE_1_1 ));
|
||||
}
|
||||
headers.emplace(Aws::Http::HeaderValuePair(Aws::Http::API_VERSION_HEADER, "2015-10-01"));
|
||||
return headers;
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const { return Aws::Http::HeaderValueCollection(); }
|
||||
|
||||
};
|
||||
|
||||
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,679 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/* Generic header includes */
|
||||
#include <aws/gamelift/GameLiftErrors.h>
|
||||
#include <aws/core/client/GenericClientConfiguration.h>
|
||||
#include <aws/core/client/AWSError.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/client/AsyncCallerContext.h>
|
||||
#include <aws/core/http/HttpTypes.h>
|
||||
#include <aws/gamelift/GameLiftEndpointProvider.h>
|
||||
#include <future>
|
||||
#include <functional>
|
||||
/* End of generic header includes */
|
||||
|
||||
/* Service model headers required in GameLiftClient header */
|
||||
#include <aws/gamelift/model/AcceptMatchResult.h>
|
||||
#include <aws/gamelift/model/ClaimGameServerResult.h>
|
||||
#include <aws/gamelift/model/CreateAliasResult.h>
|
||||
#include <aws/gamelift/model/CreateBuildResult.h>
|
||||
#include <aws/gamelift/model/CreateContainerFleetResult.h>
|
||||
#include <aws/gamelift/model/CreateContainerGroupDefinitionResult.h>
|
||||
#include <aws/gamelift/model/CreateFleetResult.h>
|
||||
#include <aws/gamelift/model/CreateFleetLocationsResult.h>
|
||||
#include <aws/gamelift/model/CreateGameServerGroupResult.h>
|
||||
#include <aws/gamelift/model/CreateGameSessionResult.h>
|
||||
#include <aws/gamelift/model/CreateGameSessionQueueResult.h>
|
||||
#include <aws/gamelift/model/CreateLocationResult.h>
|
||||
#include <aws/gamelift/model/CreateMatchmakingConfigurationResult.h>
|
||||
#include <aws/gamelift/model/CreateMatchmakingRuleSetResult.h>
|
||||
#include <aws/gamelift/model/CreatePlayerSessionResult.h>
|
||||
#include <aws/gamelift/model/CreatePlayerSessionsResult.h>
|
||||
#include <aws/gamelift/model/CreateScriptResult.h>
|
||||
#include <aws/gamelift/model/CreateVpcPeeringAuthorizationResult.h>
|
||||
#include <aws/gamelift/model/CreateVpcPeeringConnectionResult.h>
|
||||
#include <aws/gamelift/model/DeleteContainerFleetResult.h>
|
||||
#include <aws/gamelift/model/DeleteContainerGroupDefinitionResult.h>
|
||||
#include <aws/gamelift/model/DeleteFleetLocationsResult.h>
|
||||
#include <aws/gamelift/model/DeleteGameServerGroupResult.h>
|
||||
#include <aws/gamelift/model/DeleteGameSessionQueueResult.h>
|
||||
#include <aws/gamelift/model/DeleteLocationResult.h>
|
||||
#include <aws/gamelift/model/DeleteMatchmakingConfigurationResult.h>
|
||||
#include <aws/gamelift/model/DeleteMatchmakingRuleSetResult.h>
|
||||
#include <aws/gamelift/model/DeleteVpcPeeringAuthorizationResult.h>
|
||||
#include <aws/gamelift/model/DeleteVpcPeeringConnectionResult.h>
|
||||
#include <aws/gamelift/model/DeregisterComputeResult.h>
|
||||
#include <aws/gamelift/model/DescribeAliasResult.h>
|
||||
#include <aws/gamelift/model/DescribeBuildResult.h>
|
||||
#include <aws/gamelift/model/DescribeComputeResult.h>
|
||||
#include <aws/gamelift/model/DescribeContainerFleetResult.h>
|
||||
#include <aws/gamelift/model/DescribeContainerGroupDefinitionResult.h>
|
||||
#include <aws/gamelift/model/DescribeEC2InstanceLimitsResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetAttributesResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetCapacityResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetDeploymentResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetEventsResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetLocationAttributesResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetLocationCapacityResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetLocationUtilizationResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetPortSettingsResult.h>
|
||||
#include <aws/gamelift/model/DescribeFleetUtilizationResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameServerResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameServerGroupResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameServerInstancesResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionDetailsResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionPlacementResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionQueuesResult.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionsResult.h>
|
||||
#include <aws/gamelift/model/DescribeInstancesResult.h>
|
||||
#include <aws/gamelift/model/DescribeMatchmakingResult.h>
|
||||
#include <aws/gamelift/model/DescribeMatchmakingConfigurationsResult.h>
|
||||
#include <aws/gamelift/model/DescribeMatchmakingRuleSetsResult.h>
|
||||
#include <aws/gamelift/model/DescribePlayerSessionsResult.h>
|
||||
#include <aws/gamelift/model/DescribeRuntimeConfigurationResult.h>
|
||||
#include <aws/gamelift/model/DescribeScalingPoliciesResult.h>
|
||||
#include <aws/gamelift/model/DescribeScriptResult.h>
|
||||
#include <aws/gamelift/model/DescribeVpcPeeringAuthorizationsResult.h>
|
||||
#include <aws/gamelift/model/DescribeVpcPeeringConnectionsResult.h>
|
||||
#include <aws/gamelift/model/GetComputeAccessResult.h>
|
||||
#include <aws/gamelift/model/GetComputeAuthTokenResult.h>
|
||||
#include <aws/gamelift/model/GetGameSessionLogUrlResult.h>
|
||||
#include <aws/gamelift/model/GetInstanceAccessResult.h>
|
||||
#include <aws/gamelift/model/ListAliasesResult.h>
|
||||
#include <aws/gamelift/model/ListBuildsResult.h>
|
||||
#include <aws/gamelift/model/ListComputeResult.h>
|
||||
#include <aws/gamelift/model/ListContainerFleetsResult.h>
|
||||
#include <aws/gamelift/model/ListContainerGroupDefinitionVersionsResult.h>
|
||||
#include <aws/gamelift/model/ListContainerGroupDefinitionsResult.h>
|
||||
#include <aws/gamelift/model/ListFleetDeploymentsResult.h>
|
||||
#include <aws/gamelift/model/ListFleetsResult.h>
|
||||
#include <aws/gamelift/model/ListGameServerGroupsResult.h>
|
||||
#include <aws/gamelift/model/ListGameServersResult.h>
|
||||
#include <aws/gamelift/model/ListLocationsResult.h>
|
||||
#include <aws/gamelift/model/ListScriptsResult.h>
|
||||
#include <aws/gamelift/model/ListTagsForResourceResult.h>
|
||||
#include <aws/gamelift/model/PutScalingPolicyResult.h>
|
||||
#include <aws/gamelift/model/RegisterComputeResult.h>
|
||||
#include <aws/gamelift/model/RegisterGameServerResult.h>
|
||||
#include <aws/gamelift/model/RequestUploadCredentialsResult.h>
|
||||
#include <aws/gamelift/model/ResolveAliasResult.h>
|
||||
#include <aws/gamelift/model/ResumeGameServerGroupResult.h>
|
||||
#include <aws/gamelift/model/SearchGameSessionsResult.h>
|
||||
#include <aws/gamelift/model/StartFleetActionsResult.h>
|
||||
#include <aws/gamelift/model/StartGameSessionPlacementResult.h>
|
||||
#include <aws/gamelift/model/StartMatchBackfillResult.h>
|
||||
#include <aws/gamelift/model/StartMatchmakingResult.h>
|
||||
#include <aws/gamelift/model/StopFleetActionsResult.h>
|
||||
#include <aws/gamelift/model/StopGameSessionPlacementResult.h>
|
||||
#include <aws/gamelift/model/StopMatchmakingResult.h>
|
||||
#include <aws/gamelift/model/SuspendGameServerGroupResult.h>
|
||||
#include <aws/gamelift/model/TagResourceResult.h>
|
||||
#include <aws/gamelift/model/UntagResourceResult.h>
|
||||
#include <aws/gamelift/model/UpdateAliasResult.h>
|
||||
#include <aws/gamelift/model/UpdateBuildResult.h>
|
||||
#include <aws/gamelift/model/UpdateContainerFleetResult.h>
|
||||
#include <aws/gamelift/model/UpdateContainerGroupDefinitionResult.h>
|
||||
#include <aws/gamelift/model/UpdateFleetAttributesResult.h>
|
||||
#include <aws/gamelift/model/UpdateFleetCapacityResult.h>
|
||||
#include <aws/gamelift/model/UpdateFleetPortSettingsResult.h>
|
||||
#include <aws/gamelift/model/UpdateGameServerResult.h>
|
||||
#include <aws/gamelift/model/UpdateGameServerGroupResult.h>
|
||||
#include <aws/gamelift/model/UpdateGameSessionResult.h>
|
||||
#include <aws/gamelift/model/UpdateGameSessionQueueResult.h>
|
||||
#include <aws/gamelift/model/UpdateMatchmakingConfigurationResult.h>
|
||||
#include <aws/gamelift/model/UpdateRuntimeConfigurationResult.h>
|
||||
#include <aws/gamelift/model/UpdateScriptResult.h>
|
||||
#include <aws/gamelift/model/ValidateMatchmakingRuleSetResult.h>
|
||||
#include <aws/gamelift/model/ListAliasesRequest.h>
|
||||
#include <aws/gamelift/model/CreateScriptRequest.h>
|
||||
#include <aws/gamelift/model/SearchGameSessionsRequest.h>
|
||||
#include <aws/gamelift/model/DescribePlayerSessionsRequest.h>
|
||||
#include <aws/gamelift/model/ListContainerGroupDefinitionsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeFleetUtilizationRequest.h>
|
||||
#include <aws/gamelift/model/DescribeFleetAttributesRequest.h>
|
||||
#include <aws/gamelift/model/DescribeEC2InstanceLimitsRequest.h>
|
||||
#include <aws/gamelift/model/ListFleetDeploymentsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionDetailsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeMatchmakingConfigurationsRequest.h>
|
||||
#include <aws/gamelift/model/ListFleetsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeFleetCapacityRequest.h>
|
||||
#include <aws/gamelift/model/DescribeVpcPeeringAuthorizationsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionQueuesRequest.h>
|
||||
#include <aws/gamelift/model/CreateBuildRequest.h>
|
||||
#include <aws/gamelift/model/ListBuildsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeMatchmakingRuleSetsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeGameSessionsRequest.h>
|
||||
#include <aws/gamelift/model/DescribeVpcPeeringConnectionsRequest.h>
|
||||
#include <aws/gamelift/model/ListLocationsRequest.h>
|
||||
#include <aws/gamelift/model/ListContainerFleetsRequest.h>
|
||||
#include <aws/gamelift/model/ListScriptsRequest.h>
|
||||
#include <aws/gamelift/model/ListGameServerGroupsRequest.h>
|
||||
#include <aws/core/NoResult.h>
|
||||
/* End of service model headers required in GameLiftClient header */
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Http
|
||||
{
|
||||
class HttpClient;
|
||||
class HttpClientFactory;
|
||||
} // namespace Http
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
template< typename R, typename E> class Outcome;
|
||||
|
||||
namespace Threading
|
||||
{
|
||||
class Executor;
|
||||
} // namespace Threading
|
||||
} // namespace Utils
|
||||
|
||||
namespace Auth
|
||||
{
|
||||
class AWSCredentials;
|
||||
class AWSCredentialsProvider;
|
||||
} // namespace Auth
|
||||
|
||||
namespace Client
|
||||
{
|
||||
class RetryStrategy;
|
||||
} // namespace Client
|
||||
|
||||
namespace GameLift
|
||||
{
|
||||
using GameLiftClientConfiguration = Aws::Client::GenericClientConfiguration;
|
||||
using GameLiftEndpointProviderBase = Aws::GameLift::Endpoint::GameLiftEndpointProviderBase;
|
||||
using GameLiftEndpointProvider = Aws::GameLift::Endpoint::GameLiftEndpointProvider;
|
||||
|
||||
namespace Model
|
||||
{
|
||||
/* Service model forward declarations required in GameLiftClient header */
|
||||
class AcceptMatchRequest;
|
||||
class ClaimGameServerRequest;
|
||||
class CreateAliasRequest;
|
||||
class CreateBuildRequest;
|
||||
class CreateContainerFleetRequest;
|
||||
class CreateContainerGroupDefinitionRequest;
|
||||
class CreateFleetRequest;
|
||||
class CreateFleetLocationsRequest;
|
||||
class CreateGameServerGroupRequest;
|
||||
class CreateGameSessionRequest;
|
||||
class CreateGameSessionQueueRequest;
|
||||
class CreateLocationRequest;
|
||||
class CreateMatchmakingConfigurationRequest;
|
||||
class CreateMatchmakingRuleSetRequest;
|
||||
class CreatePlayerSessionRequest;
|
||||
class CreatePlayerSessionsRequest;
|
||||
class CreateScriptRequest;
|
||||
class CreateVpcPeeringAuthorizationRequest;
|
||||
class CreateVpcPeeringConnectionRequest;
|
||||
class DeleteAliasRequest;
|
||||
class DeleteBuildRequest;
|
||||
class DeleteContainerFleetRequest;
|
||||
class DeleteContainerGroupDefinitionRequest;
|
||||
class DeleteFleetRequest;
|
||||
class DeleteFleetLocationsRequest;
|
||||
class DeleteGameServerGroupRequest;
|
||||
class DeleteGameSessionQueueRequest;
|
||||
class DeleteLocationRequest;
|
||||
class DeleteMatchmakingConfigurationRequest;
|
||||
class DeleteMatchmakingRuleSetRequest;
|
||||
class DeleteScalingPolicyRequest;
|
||||
class DeleteScriptRequest;
|
||||
class DeleteVpcPeeringAuthorizationRequest;
|
||||
class DeleteVpcPeeringConnectionRequest;
|
||||
class DeregisterComputeRequest;
|
||||
class DeregisterGameServerRequest;
|
||||
class DescribeAliasRequest;
|
||||
class DescribeBuildRequest;
|
||||
class DescribeComputeRequest;
|
||||
class DescribeContainerFleetRequest;
|
||||
class DescribeContainerGroupDefinitionRequest;
|
||||
class DescribeEC2InstanceLimitsRequest;
|
||||
class DescribeFleetAttributesRequest;
|
||||
class DescribeFleetCapacityRequest;
|
||||
class DescribeFleetDeploymentRequest;
|
||||
class DescribeFleetEventsRequest;
|
||||
class DescribeFleetLocationAttributesRequest;
|
||||
class DescribeFleetLocationCapacityRequest;
|
||||
class DescribeFleetLocationUtilizationRequest;
|
||||
class DescribeFleetPortSettingsRequest;
|
||||
class DescribeFleetUtilizationRequest;
|
||||
class DescribeGameServerRequest;
|
||||
class DescribeGameServerGroupRequest;
|
||||
class DescribeGameServerInstancesRequest;
|
||||
class DescribeGameSessionDetailsRequest;
|
||||
class DescribeGameSessionPlacementRequest;
|
||||
class DescribeGameSessionQueuesRequest;
|
||||
class DescribeGameSessionsRequest;
|
||||
class DescribeInstancesRequest;
|
||||
class DescribeMatchmakingRequest;
|
||||
class DescribeMatchmakingConfigurationsRequest;
|
||||
class DescribeMatchmakingRuleSetsRequest;
|
||||
class DescribePlayerSessionsRequest;
|
||||
class DescribeRuntimeConfigurationRequest;
|
||||
class DescribeScalingPoliciesRequest;
|
||||
class DescribeScriptRequest;
|
||||
class DescribeVpcPeeringAuthorizationsRequest;
|
||||
class DescribeVpcPeeringConnectionsRequest;
|
||||
class GetComputeAccessRequest;
|
||||
class GetComputeAuthTokenRequest;
|
||||
class GetGameSessionLogUrlRequest;
|
||||
class GetInstanceAccessRequest;
|
||||
class ListAliasesRequest;
|
||||
class ListBuildsRequest;
|
||||
class ListComputeRequest;
|
||||
class ListContainerFleetsRequest;
|
||||
class ListContainerGroupDefinitionVersionsRequest;
|
||||
class ListContainerGroupDefinitionsRequest;
|
||||
class ListFleetDeploymentsRequest;
|
||||
class ListFleetsRequest;
|
||||
class ListGameServerGroupsRequest;
|
||||
class ListGameServersRequest;
|
||||
class ListLocationsRequest;
|
||||
class ListScriptsRequest;
|
||||
class ListTagsForResourceRequest;
|
||||
class PutScalingPolicyRequest;
|
||||
class RegisterComputeRequest;
|
||||
class RegisterGameServerRequest;
|
||||
class RequestUploadCredentialsRequest;
|
||||
class ResolveAliasRequest;
|
||||
class ResumeGameServerGroupRequest;
|
||||
class SearchGameSessionsRequest;
|
||||
class StartFleetActionsRequest;
|
||||
class StartGameSessionPlacementRequest;
|
||||
class StartMatchBackfillRequest;
|
||||
class StartMatchmakingRequest;
|
||||
class StopFleetActionsRequest;
|
||||
class StopGameSessionPlacementRequest;
|
||||
class StopMatchmakingRequest;
|
||||
class SuspendGameServerGroupRequest;
|
||||
class TagResourceRequest;
|
||||
class UntagResourceRequest;
|
||||
class UpdateAliasRequest;
|
||||
class UpdateBuildRequest;
|
||||
class UpdateContainerFleetRequest;
|
||||
class UpdateContainerGroupDefinitionRequest;
|
||||
class UpdateFleetAttributesRequest;
|
||||
class UpdateFleetCapacityRequest;
|
||||
class UpdateFleetPortSettingsRequest;
|
||||
class UpdateGameServerRequest;
|
||||
class UpdateGameServerGroupRequest;
|
||||
class UpdateGameSessionRequest;
|
||||
class UpdateGameSessionQueueRequest;
|
||||
class UpdateMatchmakingConfigurationRequest;
|
||||
class UpdateRuntimeConfigurationRequest;
|
||||
class UpdateScriptRequest;
|
||||
class ValidateMatchmakingRuleSetRequest;
|
||||
/* End of service model forward declarations required in GameLiftClient header */
|
||||
|
||||
/* Service model Outcome class definitions */
|
||||
typedef Aws::Utils::Outcome<AcceptMatchResult, GameLiftError> AcceptMatchOutcome;
|
||||
typedef Aws::Utils::Outcome<ClaimGameServerResult, GameLiftError> ClaimGameServerOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateAliasResult, GameLiftError> CreateAliasOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateBuildResult, GameLiftError> CreateBuildOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateContainerFleetResult, GameLiftError> CreateContainerFleetOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateContainerGroupDefinitionResult, GameLiftError> CreateContainerGroupDefinitionOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateFleetResult, GameLiftError> CreateFleetOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateFleetLocationsResult, GameLiftError> CreateFleetLocationsOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateGameServerGroupResult, GameLiftError> CreateGameServerGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateGameSessionResult, GameLiftError> CreateGameSessionOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateGameSessionQueueResult, GameLiftError> CreateGameSessionQueueOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateLocationResult, GameLiftError> CreateLocationOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateMatchmakingConfigurationResult, GameLiftError> CreateMatchmakingConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateMatchmakingRuleSetResult, GameLiftError> CreateMatchmakingRuleSetOutcome;
|
||||
typedef Aws::Utils::Outcome<CreatePlayerSessionResult, GameLiftError> CreatePlayerSessionOutcome;
|
||||
typedef Aws::Utils::Outcome<CreatePlayerSessionsResult, GameLiftError> CreatePlayerSessionsOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateScriptResult, GameLiftError> CreateScriptOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateVpcPeeringAuthorizationResult, GameLiftError> CreateVpcPeeringAuthorizationOutcome;
|
||||
typedef Aws::Utils::Outcome<CreateVpcPeeringConnectionResult, GameLiftError> CreateVpcPeeringConnectionOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, GameLiftError> DeleteAliasOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, GameLiftError> DeleteBuildOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteContainerFleetResult, GameLiftError> DeleteContainerFleetOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteContainerGroupDefinitionResult, GameLiftError> DeleteContainerGroupDefinitionOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, GameLiftError> DeleteFleetOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteFleetLocationsResult, GameLiftError> DeleteFleetLocationsOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteGameServerGroupResult, GameLiftError> DeleteGameServerGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteGameSessionQueueResult, GameLiftError> DeleteGameSessionQueueOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteLocationResult, GameLiftError> DeleteLocationOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteMatchmakingConfigurationResult, GameLiftError> DeleteMatchmakingConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteMatchmakingRuleSetResult, GameLiftError> DeleteMatchmakingRuleSetOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, GameLiftError> DeleteScalingPolicyOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, GameLiftError> DeleteScriptOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteVpcPeeringAuthorizationResult, GameLiftError> DeleteVpcPeeringAuthorizationOutcome;
|
||||
typedef Aws::Utils::Outcome<DeleteVpcPeeringConnectionResult, GameLiftError> DeleteVpcPeeringConnectionOutcome;
|
||||
typedef Aws::Utils::Outcome<DeregisterComputeResult, GameLiftError> DeregisterComputeOutcome;
|
||||
typedef Aws::Utils::Outcome<Aws::NoResult, GameLiftError> DeregisterGameServerOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeAliasResult, GameLiftError> DescribeAliasOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeBuildResult, GameLiftError> DescribeBuildOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeComputeResult, GameLiftError> DescribeComputeOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeContainerFleetResult, GameLiftError> DescribeContainerFleetOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeContainerGroupDefinitionResult, GameLiftError> DescribeContainerGroupDefinitionOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeEC2InstanceLimitsResult, GameLiftError> DescribeEC2InstanceLimitsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetAttributesResult, GameLiftError> DescribeFleetAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetCapacityResult, GameLiftError> DescribeFleetCapacityOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetDeploymentResult, GameLiftError> DescribeFleetDeploymentOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetEventsResult, GameLiftError> DescribeFleetEventsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetLocationAttributesResult, GameLiftError> DescribeFleetLocationAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetLocationCapacityResult, GameLiftError> DescribeFleetLocationCapacityOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetLocationUtilizationResult, GameLiftError> DescribeFleetLocationUtilizationOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetPortSettingsResult, GameLiftError> DescribeFleetPortSettingsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeFleetUtilizationResult, GameLiftError> DescribeFleetUtilizationOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameServerResult, GameLiftError> DescribeGameServerOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameServerGroupResult, GameLiftError> DescribeGameServerGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameServerInstancesResult, GameLiftError> DescribeGameServerInstancesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameSessionDetailsResult, GameLiftError> DescribeGameSessionDetailsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameSessionPlacementResult, GameLiftError> DescribeGameSessionPlacementOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameSessionQueuesResult, GameLiftError> DescribeGameSessionQueuesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeGameSessionsResult, GameLiftError> DescribeGameSessionsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeInstancesResult, GameLiftError> DescribeInstancesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeMatchmakingResult, GameLiftError> DescribeMatchmakingOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeMatchmakingConfigurationsResult, GameLiftError> DescribeMatchmakingConfigurationsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeMatchmakingRuleSetsResult, GameLiftError> DescribeMatchmakingRuleSetsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribePlayerSessionsResult, GameLiftError> DescribePlayerSessionsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeRuntimeConfigurationResult, GameLiftError> DescribeRuntimeConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeScalingPoliciesResult, GameLiftError> DescribeScalingPoliciesOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeScriptResult, GameLiftError> DescribeScriptOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeVpcPeeringAuthorizationsResult, GameLiftError> DescribeVpcPeeringAuthorizationsOutcome;
|
||||
typedef Aws::Utils::Outcome<DescribeVpcPeeringConnectionsResult, GameLiftError> DescribeVpcPeeringConnectionsOutcome;
|
||||
typedef Aws::Utils::Outcome<GetComputeAccessResult, GameLiftError> GetComputeAccessOutcome;
|
||||
typedef Aws::Utils::Outcome<GetComputeAuthTokenResult, GameLiftError> GetComputeAuthTokenOutcome;
|
||||
typedef Aws::Utils::Outcome<GetGameSessionLogUrlResult, GameLiftError> GetGameSessionLogUrlOutcome;
|
||||
typedef Aws::Utils::Outcome<GetInstanceAccessResult, GameLiftError> GetInstanceAccessOutcome;
|
||||
typedef Aws::Utils::Outcome<ListAliasesResult, GameLiftError> ListAliasesOutcome;
|
||||
typedef Aws::Utils::Outcome<ListBuildsResult, GameLiftError> ListBuildsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListComputeResult, GameLiftError> ListComputeOutcome;
|
||||
typedef Aws::Utils::Outcome<ListContainerFleetsResult, GameLiftError> ListContainerFleetsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListContainerGroupDefinitionVersionsResult, GameLiftError> ListContainerGroupDefinitionVersionsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListContainerGroupDefinitionsResult, GameLiftError> ListContainerGroupDefinitionsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListFleetDeploymentsResult, GameLiftError> ListFleetDeploymentsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListFleetsResult, GameLiftError> ListFleetsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListGameServerGroupsResult, GameLiftError> ListGameServerGroupsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListGameServersResult, GameLiftError> ListGameServersOutcome;
|
||||
typedef Aws::Utils::Outcome<ListLocationsResult, GameLiftError> ListLocationsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListScriptsResult, GameLiftError> ListScriptsOutcome;
|
||||
typedef Aws::Utils::Outcome<ListTagsForResourceResult, GameLiftError> ListTagsForResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<PutScalingPolicyResult, GameLiftError> PutScalingPolicyOutcome;
|
||||
typedef Aws::Utils::Outcome<RegisterComputeResult, GameLiftError> RegisterComputeOutcome;
|
||||
typedef Aws::Utils::Outcome<RegisterGameServerResult, GameLiftError> RegisterGameServerOutcome;
|
||||
typedef Aws::Utils::Outcome<RequestUploadCredentialsResult, GameLiftError> RequestUploadCredentialsOutcome;
|
||||
typedef Aws::Utils::Outcome<ResolveAliasResult, GameLiftError> ResolveAliasOutcome;
|
||||
typedef Aws::Utils::Outcome<ResumeGameServerGroupResult, GameLiftError> ResumeGameServerGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<SearchGameSessionsResult, GameLiftError> SearchGameSessionsOutcome;
|
||||
typedef Aws::Utils::Outcome<StartFleetActionsResult, GameLiftError> StartFleetActionsOutcome;
|
||||
typedef Aws::Utils::Outcome<StartGameSessionPlacementResult, GameLiftError> StartGameSessionPlacementOutcome;
|
||||
typedef Aws::Utils::Outcome<StartMatchBackfillResult, GameLiftError> StartMatchBackfillOutcome;
|
||||
typedef Aws::Utils::Outcome<StartMatchmakingResult, GameLiftError> StartMatchmakingOutcome;
|
||||
typedef Aws::Utils::Outcome<StopFleetActionsResult, GameLiftError> StopFleetActionsOutcome;
|
||||
typedef Aws::Utils::Outcome<StopGameSessionPlacementResult, GameLiftError> StopGameSessionPlacementOutcome;
|
||||
typedef Aws::Utils::Outcome<StopMatchmakingResult, GameLiftError> StopMatchmakingOutcome;
|
||||
typedef Aws::Utils::Outcome<SuspendGameServerGroupResult, GameLiftError> SuspendGameServerGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<TagResourceResult, GameLiftError> TagResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<UntagResourceResult, GameLiftError> UntagResourceOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateAliasResult, GameLiftError> UpdateAliasOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateBuildResult, GameLiftError> UpdateBuildOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateContainerFleetResult, GameLiftError> UpdateContainerFleetOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateContainerGroupDefinitionResult, GameLiftError> UpdateContainerGroupDefinitionOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateFleetAttributesResult, GameLiftError> UpdateFleetAttributesOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateFleetCapacityResult, GameLiftError> UpdateFleetCapacityOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateFleetPortSettingsResult, GameLiftError> UpdateFleetPortSettingsOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateGameServerResult, GameLiftError> UpdateGameServerOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateGameServerGroupResult, GameLiftError> UpdateGameServerGroupOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateGameSessionResult, GameLiftError> UpdateGameSessionOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateGameSessionQueueResult, GameLiftError> UpdateGameSessionQueueOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateMatchmakingConfigurationResult, GameLiftError> UpdateMatchmakingConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateRuntimeConfigurationResult, GameLiftError> UpdateRuntimeConfigurationOutcome;
|
||||
typedef Aws::Utils::Outcome<UpdateScriptResult, GameLiftError> UpdateScriptOutcome;
|
||||
typedef Aws::Utils::Outcome<ValidateMatchmakingRuleSetResult, GameLiftError> ValidateMatchmakingRuleSetOutcome;
|
||||
/* End of service model Outcome class definitions */
|
||||
|
||||
/* Service model Outcome callable definitions */
|
||||
typedef std::future<AcceptMatchOutcome> AcceptMatchOutcomeCallable;
|
||||
typedef std::future<ClaimGameServerOutcome> ClaimGameServerOutcomeCallable;
|
||||
typedef std::future<CreateAliasOutcome> CreateAliasOutcomeCallable;
|
||||
typedef std::future<CreateBuildOutcome> CreateBuildOutcomeCallable;
|
||||
typedef std::future<CreateContainerFleetOutcome> CreateContainerFleetOutcomeCallable;
|
||||
typedef std::future<CreateContainerGroupDefinitionOutcome> CreateContainerGroupDefinitionOutcomeCallable;
|
||||
typedef std::future<CreateFleetOutcome> CreateFleetOutcomeCallable;
|
||||
typedef std::future<CreateFleetLocationsOutcome> CreateFleetLocationsOutcomeCallable;
|
||||
typedef std::future<CreateGameServerGroupOutcome> CreateGameServerGroupOutcomeCallable;
|
||||
typedef std::future<CreateGameSessionOutcome> CreateGameSessionOutcomeCallable;
|
||||
typedef std::future<CreateGameSessionQueueOutcome> CreateGameSessionQueueOutcomeCallable;
|
||||
typedef std::future<CreateLocationOutcome> CreateLocationOutcomeCallable;
|
||||
typedef std::future<CreateMatchmakingConfigurationOutcome> CreateMatchmakingConfigurationOutcomeCallable;
|
||||
typedef std::future<CreateMatchmakingRuleSetOutcome> CreateMatchmakingRuleSetOutcomeCallable;
|
||||
typedef std::future<CreatePlayerSessionOutcome> CreatePlayerSessionOutcomeCallable;
|
||||
typedef std::future<CreatePlayerSessionsOutcome> CreatePlayerSessionsOutcomeCallable;
|
||||
typedef std::future<CreateScriptOutcome> CreateScriptOutcomeCallable;
|
||||
typedef std::future<CreateVpcPeeringAuthorizationOutcome> CreateVpcPeeringAuthorizationOutcomeCallable;
|
||||
typedef std::future<CreateVpcPeeringConnectionOutcome> CreateVpcPeeringConnectionOutcomeCallable;
|
||||
typedef std::future<DeleteAliasOutcome> DeleteAliasOutcomeCallable;
|
||||
typedef std::future<DeleteBuildOutcome> DeleteBuildOutcomeCallable;
|
||||
typedef std::future<DeleteContainerFleetOutcome> DeleteContainerFleetOutcomeCallable;
|
||||
typedef std::future<DeleteContainerGroupDefinitionOutcome> DeleteContainerGroupDefinitionOutcomeCallable;
|
||||
typedef std::future<DeleteFleetOutcome> DeleteFleetOutcomeCallable;
|
||||
typedef std::future<DeleteFleetLocationsOutcome> DeleteFleetLocationsOutcomeCallable;
|
||||
typedef std::future<DeleteGameServerGroupOutcome> DeleteGameServerGroupOutcomeCallable;
|
||||
typedef std::future<DeleteGameSessionQueueOutcome> DeleteGameSessionQueueOutcomeCallable;
|
||||
typedef std::future<DeleteLocationOutcome> DeleteLocationOutcomeCallable;
|
||||
typedef std::future<DeleteMatchmakingConfigurationOutcome> DeleteMatchmakingConfigurationOutcomeCallable;
|
||||
typedef std::future<DeleteMatchmakingRuleSetOutcome> DeleteMatchmakingRuleSetOutcomeCallable;
|
||||
typedef std::future<DeleteScalingPolicyOutcome> DeleteScalingPolicyOutcomeCallable;
|
||||
typedef std::future<DeleteScriptOutcome> DeleteScriptOutcomeCallable;
|
||||
typedef std::future<DeleteVpcPeeringAuthorizationOutcome> DeleteVpcPeeringAuthorizationOutcomeCallable;
|
||||
typedef std::future<DeleteVpcPeeringConnectionOutcome> DeleteVpcPeeringConnectionOutcomeCallable;
|
||||
typedef std::future<DeregisterComputeOutcome> DeregisterComputeOutcomeCallable;
|
||||
typedef std::future<DeregisterGameServerOutcome> DeregisterGameServerOutcomeCallable;
|
||||
typedef std::future<DescribeAliasOutcome> DescribeAliasOutcomeCallable;
|
||||
typedef std::future<DescribeBuildOutcome> DescribeBuildOutcomeCallable;
|
||||
typedef std::future<DescribeComputeOutcome> DescribeComputeOutcomeCallable;
|
||||
typedef std::future<DescribeContainerFleetOutcome> DescribeContainerFleetOutcomeCallable;
|
||||
typedef std::future<DescribeContainerGroupDefinitionOutcome> DescribeContainerGroupDefinitionOutcomeCallable;
|
||||
typedef std::future<DescribeEC2InstanceLimitsOutcome> DescribeEC2InstanceLimitsOutcomeCallable;
|
||||
typedef std::future<DescribeFleetAttributesOutcome> DescribeFleetAttributesOutcomeCallable;
|
||||
typedef std::future<DescribeFleetCapacityOutcome> DescribeFleetCapacityOutcomeCallable;
|
||||
typedef std::future<DescribeFleetDeploymentOutcome> DescribeFleetDeploymentOutcomeCallable;
|
||||
typedef std::future<DescribeFleetEventsOutcome> DescribeFleetEventsOutcomeCallable;
|
||||
typedef std::future<DescribeFleetLocationAttributesOutcome> DescribeFleetLocationAttributesOutcomeCallable;
|
||||
typedef std::future<DescribeFleetLocationCapacityOutcome> DescribeFleetLocationCapacityOutcomeCallable;
|
||||
typedef std::future<DescribeFleetLocationUtilizationOutcome> DescribeFleetLocationUtilizationOutcomeCallable;
|
||||
typedef std::future<DescribeFleetPortSettingsOutcome> DescribeFleetPortSettingsOutcomeCallable;
|
||||
typedef std::future<DescribeFleetUtilizationOutcome> DescribeFleetUtilizationOutcomeCallable;
|
||||
typedef std::future<DescribeGameServerOutcome> DescribeGameServerOutcomeCallable;
|
||||
typedef std::future<DescribeGameServerGroupOutcome> DescribeGameServerGroupOutcomeCallable;
|
||||
typedef std::future<DescribeGameServerInstancesOutcome> DescribeGameServerInstancesOutcomeCallable;
|
||||
typedef std::future<DescribeGameSessionDetailsOutcome> DescribeGameSessionDetailsOutcomeCallable;
|
||||
typedef std::future<DescribeGameSessionPlacementOutcome> DescribeGameSessionPlacementOutcomeCallable;
|
||||
typedef std::future<DescribeGameSessionQueuesOutcome> DescribeGameSessionQueuesOutcomeCallable;
|
||||
typedef std::future<DescribeGameSessionsOutcome> DescribeGameSessionsOutcomeCallable;
|
||||
typedef std::future<DescribeInstancesOutcome> DescribeInstancesOutcomeCallable;
|
||||
typedef std::future<DescribeMatchmakingOutcome> DescribeMatchmakingOutcomeCallable;
|
||||
typedef std::future<DescribeMatchmakingConfigurationsOutcome> DescribeMatchmakingConfigurationsOutcomeCallable;
|
||||
typedef std::future<DescribeMatchmakingRuleSetsOutcome> DescribeMatchmakingRuleSetsOutcomeCallable;
|
||||
typedef std::future<DescribePlayerSessionsOutcome> DescribePlayerSessionsOutcomeCallable;
|
||||
typedef std::future<DescribeRuntimeConfigurationOutcome> DescribeRuntimeConfigurationOutcomeCallable;
|
||||
typedef std::future<DescribeScalingPoliciesOutcome> DescribeScalingPoliciesOutcomeCallable;
|
||||
typedef std::future<DescribeScriptOutcome> DescribeScriptOutcomeCallable;
|
||||
typedef std::future<DescribeVpcPeeringAuthorizationsOutcome> DescribeVpcPeeringAuthorizationsOutcomeCallable;
|
||||
typedef std::future<DescribeVpcPeeringConnectionsOutcome> DescribeVpcPeeringConnectionsOutcomeCallable;
|
||||
typedef std::future<GetComputeAccessOutcome> GetComputeAccessOutcomeCallable;
|
||||
typedef std::future<GetComputeAuthTokenOutcome> GetComputeAuthTokenOutcomeCallable;
|
||||
typedef std::future<GetGameSessionLogUrlOutcome> GetGameSessionLogUrlOutcomeCallable;
|
||||
typedef std::future<GetInstanceAccessOutcome> GetInstanceAccessOutcomeCallable;
|
||||
typedef std::future<ListAliasesOutcome> ListAliasesOutcomeCallable;
|
||||
typedef std::future<ListBuildsOutcome> ListBuildsOutcomeCallable;
|
||||
typedef std::future<ListComputeOutcome> ListComputeOutcomeCallable;
|
||||
typedef std::future<ListContainerFleetsOutcome> ListContainerFleetsOutcomeCallable;
|
||||
typedef std::future<ListContainerGroupDefinitionVersionsOutcome> ListContainerGroupDefinitionVersionsOutcomeCallable;
|
||||
typedef std::future<ListContainerGroupDefinitionsOutcome> ListContainerGroupDefinitionsOutcomeCallable;
|
||||
typedef std::future<ListFleetDeploymentsOutcome> ListFleetDeploymentsOutcomeCallable;
|
||||
typedef std::future<ListFleetsOutcome> ListFleetsOutcomeCallable;
|
||||
typedef std::future<ListGameServerGroupsOutcome> ListGameServerGroupsOutcomeCallable;
|
||||
typedef std::future<ListGameServersOutcome> ListGameServersOutcomeCallable;
|
||||
typedef std::future<ListLocationsOutcome> ListLocationsOutcomeCallable;
|
||||
typedef std::future<ListScriptsOutcome> ListScriptsOutcomeCallable;
|
||||
typedef std::future<ListTagsForResourceOutcome> ListTagsForResourceOutcomeCallable;
|
||||
typedef std::future<PutScalingPolicyOutcome> PutScalingPolicyOutcomeCallable;
|
||||
typedef std::future<RegisterComputeOutcome> RegisterComputeOutcomeCallable;
|
||||
typedef std::future<RegisterGameServerOutcome> RegisterGameServerOutcomeCallable;
|
||||
typedef std::future<RequestUploadCredentialsOutcome> RequestUploadCredentialsOutcomeCallable;
|
||||
typedef std::future<ResolveAliasOutcome> ResolveAliasOutcomeCallable;
|
||||
typedef std::future<ResumeGameServerGroupOutcome> ResumeGameServerGroupOutcomeCallable;
|
||||
typedef std::future<SearchGameSessionsOutcome> SearchGameSessionsOutcomeCallable;
|
||||
typedef std::future<StartFleetActionsOutcome> StartFleetActionsOutcomeCallable;
|
||||
typedef std::future<StartGameSessionPlacementOutcome> StartGameSessionPlacementOutcomeCallable;
|
||||
typedef std::future<StartMatchBackfillOutcome> StartMatchBackfillOutcomeCallable;
|
||||
typedef std::future<StartMatchmakingOutcome> StartMatchmakingOutcomeCallable;
|
||||
typedef std::future<StopFleetActionsOutcome> StopFleetActionsOutcomeCallable;
|
||||
typedef std::future<StopGameSessionPlacementOutcome> StopGameSessionPlacementOutcomeCallable;
|
||||
typedef std::future<StopMatchmakingOutcome> StopMatchmakingOutcomeCallable;
|
||||
typedef std::future<SuspendGameServerGroupOutcome> SuspendGameServerGroupOutcomeCallable;
|
||||
typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
|
||||
typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
|
||||
typedef std::future<UpdateAliasOutcome> UpdateAliasOutcomeCallable;
|
||||
typedef std::future<UpdateBuildOutcome> UpdateBuildOutcomeCallable;
|
||||
typedef std::future<UpdateContainerFleetOutcome> UpdateContainerFleetOutcomeCallable;
|
||||
typedef std::future<UpdateContainerGroupDefinitionOutcome> UpdateContainerGroupDefinitionOutcomeCallable;
|
||||
typedef std::future<UpdateFleetAttributesOutcome> UpdateFleetAttributesOutcomeCallable;
|
||||
typedef std::future<UpdateFleetCapacityOutcome> UpdateFleetCapacityOutcomeCallable;
|
||||
typedef std::future<UpdateFleetPortSettingsOutcome> UpdateFleetPortSettingsOutcomeCallable;
|
||||
typedef std::future<UpdateGameServerOutcome> UpdateGameServerOutcomeCallable;
|
||||
typedef std::future<UpdateGameServerGroupOutcome> UpdateGameServerGroupOutcomeCallable;
|
||||
typedef std::future<UpdateGameSessionOutcome> UpdateGameSessionOutcomeCallable;
|
||||
typedef std::future<UpdateGameSessionQueueOutcome> UpdateGameSessionQueueOutcomeCallable;
|
||||
typedef std::future<UpdateMatchmakingConfigurationOutcome> UpdateMatchmakingConfigurationOutcomeCallable;
|
||||
typedef std::future<UpdateRuntimeConfigurationOutcome> UpdateRuntimeConfigurationOutcomeCallable;
|
||||
typedef std::future<UpdateScriptOutcome> UpdateScriptOutcomeCallable;
|
||||
typedef std::future<ValidateMatchmakingRuleSetOutcome> ValidateMatchmakingRuleSetOutcomeCallable;
|
||||
/* End of service model Outcome callable definitions */
|
||||
} // namespace Model
|
||||
|
||||
class GameLiftClient;
|
||||
|
||||
/* Service model async handlers definitions */
|
||||
typedef std::function<void(const GameLiftClient*, const Model::AcceptMatchRequest&, const Model::AcceptMatchOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > AcceptMatchResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ClaimGameServerRequest&, const Model::ClaimGameServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ClaimGameServerResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateAliasRequest&, const Model::CreateAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateAliasResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateBuildRequest&, const Model::CreateBuildOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateBuildResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateContainerFleetRequest&, const Model::CreateContainerFleetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateContainerFleetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateContainerGroupDefinitionRequest&, const Model::CreateContainerGroupDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateContainerGroupDefinitionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateFleetRequest&, const Model::CreateFleetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateFleetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateFleetLocationsRequest&, const Model::CreateFleetLocationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateFleetLocationsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateGameServerGroupRequest&, const Model::CreateGameServerGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGameServerGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateGameSessionRequest&, const Model::CreateGameSessionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGameSessionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateGameSessionQueueRequest&, const Model::CreateGameSessionQueueOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateGameSessionQueueResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateLocationRequest&, const Model::CreateLocationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateLocationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateMatchmakingConfigurationRequest&, const Model::CreateMatchmakingConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateMatchmakingConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateMatchmakingRuleSetRequest&, const Model::CreateMatchmakingRuleSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateMatchmakingRuleSetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreatePlayerSessionRequest&, const Model::CreatePlayerSessionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreatePlayerSessionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreatePlayerSessionsRequest&, const Model::CreatePlayerSessionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreatePlayerSessionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateScriptRequest&, const Model::CreateScriptOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateScriptResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateVpcPeeringAuthorizationRequest&, const Model::CreateVpcPeeringAuthorizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateVpcPeeringAuthorizationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::CreateVpcPeeringConnectionRequest&, const Model::CreateVpcPeeringConnectionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > CreateVpcPeeringConnectionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteAliasRequest&, const Model::DeleteAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteAliasResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteBuildRequest&, const Model::DeleteBuildOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteBuildResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteContainerFleetRequest&, const Model::DeleteContainerFleetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteContainerFleetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteContainerGroupDefinitionRequest&, const Model::DeleteContainerGroupDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteContainerGroupDefinitionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteFleetRequest&, const Model::DeleteFleetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteFleetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteFleetLocationsRequest&, const Model::DeleteFleetLocationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteFleetLocationsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteGameServerGroupRequest&, const Model::DeleteGameServerGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteGameServerGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteGameSessionQueueRequest&, const Model::DeleteGameSessionQueueOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteGameSessionQueueResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteLocationRequest&, const Model::DeleteLocationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteLocationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteMatchmakingConfigurationRequest&, const Model::DeleteMatchmakingConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteMatchmakingConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteMatchmakingRuleSetRequest&, const Model::DeleteMatchmakingRuleSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteMatchmakingRuleSetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteScalingPolicyRequest&, const Model::DeleteScalingPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteScalingPolicyResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteScriptRequest&, const Model::DeleteScriptOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteScriptResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteVpcPeeringAuthorizationRequest&, const Model::DeleteVpcPeeringAuthorizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteVpcPeeringAuthorizationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeleteVpcPeeringConnectionRequest&, const Model::DeleteVpcPeeringConnectionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeleteVpcPeeringConnectionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeregisterComputeRequest&, const Model::DeregisterComputeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeregisterComputeResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DeregisterGameServerRequest&, const Model::DeregisterGameServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DeregisterGameServerResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeAliasRequest&, const Model::DescribeAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeAliasResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeBuildRequest&, const Model::DescribeBuildOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeBuildResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeComputeRequest&, const Model::DescribeComputeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeComputeResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeContainerFleetRequest&, const Model::DescribeContainerFleetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeContainerFleetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeContainerGroupDefinitionRequest&, const Model::DescribeContainerGroupDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeContainerGroupDefinitionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeEC2InstanceLimitsRequest&, const Model::DescribeEC2InstanceLimitsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeEC2InstanceLimitsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetAttributesRequest&, const Model::DescribeFleetAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetCapacityRequest&, const Model::DescribeFleetCapacityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetCapacityResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetDeploymentRequest&, const Model::DescribeFleetDeploymentOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetDeploymentResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetEventsRequest&, const Model::DescribeFleetEventsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetEventsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetLocationAttributesRequest&, const Model::DescribeFleetLocationAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetLocationAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetLocationCapacityRequest&, const Model::DescribeFleetLocationCapacityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetLocationCapacityResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetLocationUtilizationRequest&, const Model::DescribeFleetLocationUtilizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetLocationUtilizationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetPortSettingsRequest&, const Model::DescribeFleetPortSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetPortSettingsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeFleetUtilizationRequest&, const Model::DescribeFleetUtilizationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeFleetUtilizationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameServerRequest&, const Model::DescribeGameServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameServerResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameServerGroupRequest&, const Model::DescribeGameServerGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameServerGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameServerInstancesRequest&, const Model::DescribeGameServerInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameServerInstancesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameSessionDetailsRequest&, const Model::DescribeGameSessionDetailsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameSessionDetailsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameSessionPlacementRequest&, const Model::DescribeGameSessionPlacementOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameSessionPlacementResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameSessionQueuesRequest&, const Model::DescribeGameSessionQueuesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameSessionQueuesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeGameSessionsRequest&, const Model::DescribeGameSessionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeGameSessionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeInstancesRequest&, const Model::DescribeInstancesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeInstancesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeMatchmakingRequest&, const Model::DescribeMatchmakingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeMatchmakingResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeMatchmakingConfigurationsRequest&, const Model::DescribeMatchmakingConfigurationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeMatchmakingConfigurationsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeMatchmakingRuleSetsRequest&, const Model::DescribeMatchmakingRuleSetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeMatchmakingRuleSetsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribePlayerSessionsRequest&, const Model::DescribePlayerSessionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribePlayerSessionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeRuntimeConfigurationRequest&, const Model::DescribeRuntimeConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeRuntimeConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeScalingPoliciesRequest&, const Model::DescribeScalingPoliciesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeScalingPoliciesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeScriptRequest&, const Model::DescribeScriptOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeScriptResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeVpcPeeringAuthorizationsRequest&, const Model::DescribeVpcPeeringAuthorizationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeVpcPeeringAuthorizationsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::DescribeVpcPeeringConnectionsRequest&, const Model::DescribeVpcPeeringConnectionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > DescribeVpcPeeringConnectionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::GetComputeAccessRequest&, const Model::GetComputeAccessOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetComputeAccessResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::GetComputeAuthTokenRequest&, const Model::GetComputeAuthTokenOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetComputeAuthTokenResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::GetGameSessionLogUrlRequest&, const Model::GetGameSessionLogUrlOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetGameSessionLogUrlResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::GetInstanceAccessRequest&, const Model::GetInstanceAccessOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetInstanceAccessResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListAliasesRequest&, const Model::ListAliasesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListAliasesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListBuildsRequest&, const Model::ListBuildsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListBuildsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListComputeRequest&, const Model::ListComputeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListComputeResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListContainerFleetsRequest&, const Model::ListContainerFleetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListContainerFleetsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListContainerGroupDefinitionVersionsRequest&, const Model::ListContainerGroupDefinitionVersionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListContainerGroupDefinitionVersionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListContainerGroupDefinitionsRequest&, const Model::ListContainerGroupDefinitionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListContainerGroupDefinitionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListFleetDeploymentsRequest&, const Model::ListFleetDeploymentsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListFleetDeploymentsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListFleetsRequest&, const Model::ListFleetsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListFleetsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListGameServerGroupsRequest&, const Model::ListGameServerGroupsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGameServerGroupsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListGameServersRequest&, const Model::ListGameServersOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListGameServersResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListLocationsRequest&, const Model::ListLocationsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListLocationsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListScriptsRequest&, const Model::ListScriptsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListScriptsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ListTagsForResourceRequest&, const Model::ListTagsForResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ListTagsForResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::PutScalingPolicyRequest&, const Model::PutScalingPolicyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > PutScalingPolicyResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::RegisterComputeRequest&, const Model::RegisterComputeOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterComputeResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::RegisterGameServerRequest&, const Model::RegisterGameServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RegisterGameServerResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::RequestUploadCredentialsRequest&, const Model::RequestUploadCredentialsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > RequestUploadCredentialsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ResolveAliasRequest&, const Model::ResolveAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ResolveAliasResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ResumeGameServerGroupRequest&, const Model::ResumeGameServerGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ResumeGameServerGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::SearchGameSessionsRequest&, const Model::SearchGameSessionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SearchGameSessionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StartFleetActionsRequest&, const Model::StartFleetActionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartFleetActionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StartGameSessionPlacementRequest&, const Model::StartGameSessionPlacementOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartGameSessionPlacementResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StartMatchBackfillRequest&, const Model::StartMatchBackfillOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartMatchBackfillResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StartMatchmakingRequest&, const Model::StartMatchmakingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StartMatchmakingResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StopFleetActionsRequest&, const Model::StopFleetActionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopFleetActionsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StopGameSessionPlacementRequest&, const Model::StopGameSessionPlacementOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopGameSessionPlacementResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::StopMatchmakingRequest&, const Model::StopMatchmakingOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > StopMatchmakingResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::SuspendGameServerGroupRequest&, const Model::SuspendGameServerGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > SuspendGameServerGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::TagResourceRequest&, const Model::TagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > TagResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UntagResourceRequest&, const Model::UntagResourceOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UntagResourceResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateAliasRequest&, const Model::UpdateAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateAliasResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateBuildRequest&, const Model::UpdateBuildOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateBuildResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateContainerFleetRequest&, const Model::UpdateContainerFleetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateContainerFleetResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateContainerGroupDefinitionRequest&, const Model::UpdateContainerGroupDefinitionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateContainerGroupDefinitionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateFleetAttributesRequest&, const Model::UpdateFleetAttributesOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateFleetAttributesResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateFleetCapacityRequest&, const Model::UpdateFleetCapacityOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateFleetCapacityResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateFleetPortSettingsRequest&, const Model::UpdateFleetPortSettingsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateFleetPortSettingsResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateGameServerRequest&, const Model::UpdateGameServerOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGameServerResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateGameServerGroupRequest&, const Model::UpdateGameServerGroupOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGameServerGroupResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateGameSessionRequest&, const Model::UpdateGameSessionOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGameSessionResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateGameSessionQueueRequest&, const Model::UpdateGameSessionQueueOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateGameSessionQueueResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateMatchmakingConfigurationRequest&, const Model::UpdateMatchmakingConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateMatchmakingConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateRuntimeConfigurationRequest&, const Model::UpdateRuntimeConfigurationOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateRuntimeConfigurationResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::UpdateScriptRequest&, const Model::UpdateScriptOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > UpdateScriptResponseReceivedHandler;
|
||||
typedef std::function<void(const GameLiftClient*, const Model::ValidateMatchmakingRuleSetRequest&, const Model::ValidateMatchmakingRuleSetOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ValidateMatchmakingRuleSetResponseReceivedHandler;
|
||||
/* End of service model async handlers definitions */
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef _MSC_VER
|
||||
//disable windows complaining about max template size.
|
||||
#pragma warning (disable : 4503)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if defined (USE_WINDOWS_DLL_SEMANTICS) || defined (_WIN32)
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable : 4251)
|
||||
#endif // _MSC_VER
|
||||
|
||||
#ifdef USE_IMPORT_EXPORT
|
||||
#ifdef AWS_GAMELIFT_EXPORTS
|
||||
#define AWS_GAMELIFT_API __declspec(dllexport)
|
||||
#else
|
||||
#define AWS_GAMELIFT_API __declspec(dllimport)
|
||||
#endif /* AWS_GAMELIFT_EXPORTS */
|
||||
#define AWS_GAMELIFT_EXTERN
|
||||
#else
|
||||
#define AWS_GAMELIFT_API
|
||||
#define AWS_GAMELIFT_EXTERN extern
|
||||
#endif // USE_IMPORT_EXPORT
|
||||
#else // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
|
||||
#define AWS_GAMELIFT_API
|
||||
#define AWS_GAMELIFT_EXTERN extern
|
||||
#endif // defined (USE_WINDOWS_DLL_SEMANTICS) || defined (WIN32)
|
||||
@@ -0,0 +1,95 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/AcceptanceType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class AcceptMatchRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API AcceptMatchRequest();
|
||||
|
||||
// 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 "AcceptMatch"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a matchmaking ticket. The ticket must be in status
|
||||
* <code>REQUIRES_ACCEPTANCE</code>; otherwise this request will fail.</p>
|
||||
*/
|
||||
inline const Aws::String& GetTicketId() const{ return m_ticketId; }
|
||||
inline bool TicketIdHasBeenSet() const { return m_ticketIdHasBeenSet; }
|
||||
inline void SetTicketId(const Aws::String& value) { m_ticketIdHasBeenSet = true; m_ticketId = value; }
|
||||
inline void SetTicketId(Aws::String&& value) { m_ticketIdHasBeenSet = true; m_ticketId = std::move(value); }
|
||||
inline void SetTicketId(const char* value) { m_ticketIdHasBeenSet = true; m_ticketId.assign(value); }
|
||||
inline AcceptMatchRequest& WithTicketId(const Aws::String& value) { SetTicketId(value); return *this;}
|
||||
inline AcceptMatchRequest& WithTicketId(Aws::String&& value) { SetTicketId(std::move(value)); return *this;}
|
||||
inline AcceptMatchRequest& WithTicketId(const char* value) { SetTicketId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a player delivering the response. This parameter can
|
||||
* include one or multiple player IDs.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetPlayerIds() const{ return m_playerIds; }
|
||||
inline bool PlayerIdsHasBeenSet() const { return m_playerIdsHasBeenSet; }
|
||||
inline void SetPlayerIds(const Aws::Vector<Aws::String>& value) { m_playerIdsHasBeenSet = true; m_playerIds = value; }
|
||||
inline void SetPlayerIds(Aws::Vector<Aws::String>&& value) { m_playerIdsHasBeenSet = true; m_playerIds = std::move(value); }
|
||||
inline AcceptMatchRequest& WithPlayerIds(const Aws::Vector<Aws::String>& value) { SetPlayerIds(value); return *this;}
|
||||
inline AcceptMatchRequest& WithPlayerIds(Aws::Vector<Aws::String>&& value) { SetPlayerIds(std::move(value)); return *this;}
|
||||
inline AcceptMatchRequest& AddPlayerIds(const Aws::String& value) { m_playerIdsHasBeenSet = true; m_playerIds.push_back(value); return *this; }
|
||||
inline AcceptMatchRequest& AddPlayerIds(Aws::String&& value) { m_playerIdsHasBeenSet = true; m_playerIds.push_back(std::move(value)); return *this; }
|
||||
inline AcceptMatchRequest& AddPlayerIds(const char* value) { m_playerIdsHasBeenSet = true; m_playerIds.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Player response to the proposed match.</p>
|
||||
*/
|
||||
inline const AcceptanceType& GetAcceptanceType() const{ return m_acceptanceType; }
|
||||
inline bool AcceptanceTypeHasBeenSet() const { return m_acceptanceTypeHasBeenSet; }
|
||||
inline void SetAcceptanceType(const AcceptanceType& value) { m_acceptanceTypeHasBeenSet = true; m_acceptanceType = value; }
|
||||
inline void SetAcceptanceType(AcceptanceType&& value) { m_acceptanceTypeHasBeenSet = true; m_acceptanceType = std::move(value); }
|
||||
inline AcceptMatchRequest& WithAcceptanceType(const AcceptanceType& value) { SetAcceptanceType(value); return *this;}
|
||||
inline AcceptMatchRequest& WithAcceptanceType(AcceptanceType&& value) { SetAcceptanceType(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_ticketId;
|
||||
bool m_ticketIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_playerIds;
|
||||
bool m_playerIdsHasBeenSet = false;
|
||||
|
||||
AcceptanceType m_acceptanceType;
|
||||
bool m_acceptanceTypeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class AcceptMatchResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API AcceptMatchResult();
|
||||
AWS_GAMELIFT_API AcceptMatchResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API AcceptMatchResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline AcceptMatchResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline AcceptMatchResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline AcceptMatchResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class AcceptanceType
|
||||
{
|
||||
NOT_SET,
|
||||
ACCEPT,
|
||||
REJECT
|
||||
};
|
||||
|
||||
namespace AcceptanceTypeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API AcceptanceType GetAcceptanceTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForAcceptanceType(AcceptanceType value);
|
||||
} // namespace AcceptanceTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,173 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/RoutingStrategy.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Properties that describe an alias resource.</p> <p> <b>Related actions</b>
|
||||
* </p> <p> <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All
|
||||
* APIs by task</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/Alias">AWS API
|
||||
* Reference</a></p>
|
||||
*/
|
||||
class Alias
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API Alias();
|
||||
AWS_GAMELIFT_API Alias(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Alias& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the alias. Alias IDs are unique within a Region.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAliasId() const{ return m_aliasId; }
|
||||
inline bool AliasIdHasBeenSet() const { return m_aliasIdHasBeenSet; }
|
||||
inline void SetAliasId(const Aws::String& value) { m_aliasIdHasBeenSet = true; m_aliasId = value; }
|
||||
inline void SetAliasId(Aws::String&& value) { m_aliasIdHasBeenSet = true; m_aliasId = std::move(value); }
|
||||
inline void SetAliasId(const char* value) { m_aliasIdHasBeenSet = true; m_aliasId.assign(value); }
|
||||
inline Alias& WithAliasId(const Aws::String& value) { SetAliasId(value); return *this;}
|
||||
inline Alias& WithAliasId(Aws::String&& value) { SetAliasId(std::move(value)); return *this;}
|
||||
inline Alias& WithAliasId(const char* value) { SetAliasId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with an alias. Alias names do not need
|
||||
* to be unique.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline Alias& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline Alias& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline Alias& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to a Amazon GameLift alias resource and uniquely identifies it.
|
||||
* ARNs are unique across all Regions. Format is
|
||||
* <code>arn:aws:gamelift:<region>::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912</code>.
|
||||
* In a GameLift alias ARN, the resource ID matches the alias ID value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAliasArn() const{ return m_aliasArn; }
|
||||
inline bool AliasArnHasBeenSet() const { return m_aliasArnHasBeenSet; }
|
||||
inline void SetAliasArn(const Aws::String& value) { m_aliasArnHasBeenSet = true; m_aliasArn = value; }
|
||||
inline void SetAliasArn(Aws::String&& value) { m_aliasArnHasBeenSet = true; m_aliasArn = std::move(value); }
|
||||
inline void SetAliasArn(const char* value) { m_aliasArnHasBeenSet = true; m_aliasArn.assign(value); }
|
||||
inline Alias& WithAliasArn(const Aws::String& value) { SetAliasArn(value); return *this;}
|
||||
inline Alias& WithAliasArn(Aws::String&& value) { SetAliasArn(std::move(value)); return *this;}
|
||||
inline Alias& WithAliasArn(const char* value) { SetAliasArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A human-readable description of an alias.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline Alias& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline Alias& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline Alias& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The routing configuration, including routing type and fleet target, for the
|
||||
* alias. </p>
|
||||
*/
|
||||
inline const RoutingStrategy& GetRoutingStrategy() const{ return m_routingStrategy; }
|
||||
inline bool RoutingStrategyHasBeenSet() const { return m_routingStrategyHasBeenSet; }
|
||||
inline void SetRoutingStrategy(const RoutingStrategy& value) { m_routingStrategyHasBeenSet = true; m_routingStrategy = value; }
|
||||
inline void SetRoutingStrategy(RoutingStrategy&& value) { m_routingStrategyHasBeenSet = true; m_routingStrategy = std::move(value); }
|
||||
inline Alias& WithRoutingStrategy(const RoutingStrategy& value) { SetRoutingStrategy(value); return *this;}
|
||||
inline Alias& WithRoutingStrategy(RoutingStrategy&& value) { SetRoutingStrategy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A time stamp indicating when this data object was created. Format is a number
|
||||
* expressed in Unix time as milliseconds (for example
|
||||
* <code>"1469498468.057"</code>).</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
|
||||
inline Alias& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline Alias& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time that this data object was last modified. Format is a number
|
||||
* expressed in Unix time as milliseconds (for example
|
||||
* <code>"1469498468.057"</code>).</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetLastUpdatedTime() const{ return m_lastUpdatedTime; }
|
||||
inline bool LastUpdatedTimeHasBeenSet() const { return m_lastUpdatedTimeHasBeenSet; }
|
||||
inline void SetLastUpdatedTime(const Aws::Utils::DateTime& value) { m_lastUpdatedTimeHasBeenSet = true; m_lastUpdatedTime = value; }
|
||||
inline void SetLastUpdatedTime(Aws::Utils::DateTime&& value) { m_lastUpdatedTimeHasBeenSet = true; m_lastUpdatedTime = std::move(value); }
|
||||
inline Alias& WithLastUpdatedTime(const Aws::Utils::DateTime& value) { SetLastUpdatedTime(value); return *this;}
|
||||
inline Alias& WithLastUpdatedTime(Aws::Utils::DateTime&& value) { SetLastUpdatedTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_aliasId;
|
||||
bool m_aliasIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_aliasArn;
|
||||
bool m_aliasArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
RoutingStrategy m_routingStrategy;
|
||||
bool m_routingStrategyHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
bool m_creationTimeHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_lastUpdatedTime;
|
||||
bool m_lastUpdatedTimeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Amazon GameLift configuration options for your Anywhere fleets.</p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/AnywhereConfiguration">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AnywhereConfiguration
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API AnywhereConfiguration();
|
||||
AWS_GAMELIFT_API AnywhereConfiguration(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API AnywhereConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The cost to run your fleet per hour. Amazon GameLift uses the provided cost
|
||||
* of your fleet to balance usage in queues. For more information about queues, see
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-intro.html">Setting
|
||||
* up queues</a> in the <i>Amazon GameLift Developer Guide</i>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetCost() const{ return m_cost; }
|
||||
inline bool CostHasBeenSet() const { return m_costHasBeenSet; }
|
||||
inline void SetCost(const Aws::String& value) { m_costHasBeenSet = true; m_cost = value; }
|
||||
inline void SetCost(Aws::String&& value) { m_costHasBeenSet = true; m_cost = std::move(value); }
|
||||
inline void SetCost(const char* value) { m_costHasBeenSet = true; m_cost.assign(value); }
|
||||
inline AnywhereConfiguration& WithCost(const Aws::String& value) { SetCost(value); return *this;}
|
||||
inline AnywhereConfiguration& WithCost(Aws::String&& value) { SetCost(std::move(value)); return *this;}
|
||||
inline AnywhereConfiguration& WithCost(const char* value) { SetCost(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_cost;
|
||||
bool m_costHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Values for use in player attribute key-value pairs. This object lets you
|
||||
* specify an attribute value using any of the valid data types: string, number,
|
||||
* string array, or data map. Each <code>AttributeValue</code> object can use only
|
||||
* one of the available properties.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/AttributeValue">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AttributeValue
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API AttributeValue();
|
||||
AWS_GAMELIFT_API AttributeValue(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API AttributeValue& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>For single string values. Maximum string length is 100 characters.</p>
|
||||
*/
|
||||
inline const Aws::String& GetS() const{ return m_s; }
|
||||
inline bool SHasBeenSet() const { return m_sHasBeenSet; }
|
||||
inline void SetS(const Aws::String& value) { m_sHasBeenSet = true; m_s = value; }
|
||||
inline void SetS(Aws::String&& value) { m_sHasBeenSet = true; m_s = std::move(value); }
|
||||
inline void SetS(const char* value) { m_sHasBeenSet = true; m_s.assign(value); }
|
||||
inline AttributeValue& WithS(const Aws::String& value) { SetS(value); return *this;}
|
||||
inline AttributeValue& WithS(Aws::String&& value) { SetS(std::move(value)); return *this;}
|
||||
inline AttributeValue& WithS(const char* value) { SetS(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>For number values, expressed as double.</p>
|
||||
*/
|
||||
inline double GetN() const{ return m_n; }
|
||||
inline bool NHasBeenSet() const { return m_nHasBeenSet; }
|
||||
inline void SetN(double value) { m_nHasBeenSet = true; m_n = value; }
|
||||
inline AttributeValue& WithN(double value) { SetN(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>For a list of up to 100 strings. Maximum length for each string is 100
|
||||
* characters. Duplicate values are not recognized; all occurrences of the repeated
|
||||
* value after the first of a repeated value are ignored.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetSL() const{ return m_sL; }
|
||||
inline bool SLHasBeenSet() const { return m_sLHasBeenSet; }
|
||||
inline void SetSL(const Aws::Vector<Aws::String>& value) { m_sLHasBeenSet = true; m_sL = value; }
|
||||
inline void SetSL(Aws::Vector<Aws::String>&& value) { m_sLHasBeenSet = true; m_sL = std::move(value); }
|
||||
inline AttributeValue& WithSL(const Aws::Vector<Aws::String>& value) { SetSL(value); return *this;}
|
||||
inline AttributeValue& WithSL(Aws::Vector<Aws::String>&& value) { SetSL(std::move(value)); return *this;}
|
||||
inline AttributeValue& AddSL(const Aws::String& value) { m_sLHasBeenSet = true; m_sL.push_back(value); return *this; }
|
||||
inline AttributeValue& AddSL(Aws::String&& value) { m_sLHasBeenSet = true; m_sL.push_back(std::move(value)); return *this; }
|
||||
inline AttributeValue& AddSL(const char* value) { m_sLHasBeenSet = true; m_sL.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>For a map of up to 10 data type:value pairs. Maximum length for each string
|
||||
* value is 100 characters. </p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, double>& GetSDM() const{ return m_sDM; }
|
||||
inline bool SDMHasBeenSet() const { return m_sDMHasBeenSet; }
|
||||
inline void SetSDM(const Aws::Map<Aws::String, double>& value) { m_sDMHasBeenSet = true; m_sDM = value; }
|
||||
inline void SetSDM(Aws::Map<Aws::String, double>&& value) { m_sDMHasBeenSet = true; m_sDM = std::move(value); }
|
||||
inline AttributeValue& WithSDM(const Aws::Map<Aws::String, double>& value) { SetSDM(value); return *this;}
|
||||
inline AttributeValue& WithSDM(Aws::Map<Aws::String, double>&& value) { SetSDM(std::move(value)); return *this;}
|
||||
inline AttributeValue& AddSDM(const Aws::String& key, double value) { m_sDMHasBeenSet = true; m_sDM.emplace(key, value); return *this; }
|
||||
inline AttributeValue& AddSDM(Aws::String&& key, double value) { m_sDMHasBeenSet = true; m_sDM.emplace(std::move(key), value); return *this; }
|
||||
inline AttributeValue& AddSDM(const char* key, double value) { m_sDMHasBeenSet = true; m_sDM.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_s;
|
||||
bool m_sHasBeenSet = false;
|
||||
|
||||
double m_n;
|
||||
bool m_nHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_sL;
|
||||
bool m_sLHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, double> m_sDM;
|
||||
bool m_sDMHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,107 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Amazon Web Services account security credentials that allow interactions with
|
||||
* Amazon GameLift resources. The credentials are temporary and valid for a limited
|
||||
* time span. You can request fresh credentials at any time. </p> <p> Amazon Web
|
||||
* Services security credentials consist of three parts: an access key ID, a secret
|
||||
* access key, and a session token. You must use all three parts together to
|
||||
* authenticate your access requests.</p> <p>You need Amazon Web Services
|
||||
* credentials for the following tasks: </p> <ul> <li> <p>To upload a game server
|
||||
* build directly to Amazon GameLift S3 storage using <code>CreateBuild</code>. To
|
||||
* get access for this task, call <a>RequestUploadCredentials</a>.</p> </li> <li>
|
||||
* <p>To remotely connect to an active Amazon GameLift fleet instances. To get
|
||||
* remote access, call <a>GetComputeAccess</a>.</p> </li> </ul><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/AwsCredentials">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class AwsCredentials
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API AwsCredentials();
|
||||
AWS_GAMELIFT_API AwsCredentials(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API AwsCredentials& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The access key ID that identifies the temporary security credentials. </p>
|
||||
*/
|
||||
inline const Aws::String& GetAccessKeyId() const{ return m_accessKeyId; }
|
||||
inline bool AccessKeyIdHasBeenSet() const { return m_accessKeyIdHasBeenSet; }
|
||||
inline void SetAccessKeyId(const Aws::String& value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId = value; }
|
||||
inline void SetAccessKeyId(Aws::String&& value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId = std::move(value); }
|
||||
inline void SetAccessKeyId(const char* value) { m_accessKeyIdHasBeenSet = true; m_accessKeyId.assign(value); }
|
||||
inline AwsCredentials& WithAccessKeyId(const Aws::String& value) { SetAccessKeyId(value); return *this;}
|
||||
inline AwsCredentials& WithAccessKeyId(Aws::String&& value) { SetAccessKeyId(std::move(value)); return *this;}
|
||||
inline AwsCredentials& WithAccessKeyId(const char* value) { SetAccessKeyId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The secret access key that can be used to sign requests.</p>
|
||||
*/
|
||||
inline const Aws::String& GetSecretAccessKey() const{ return m_secretAccessKey; }
|
||||
inline bool SecretAccessKeyHasBeenSet() const { return m_secretAccessKeyHasBeenSet; }
|
||||
inline void SetSecretAccessKey(const Aws::String& value) { m_secretAccessKeyHasBeenSet = true; m_secretAccessKey = value; }
|
||||
inline void SetSecretAccessKey(Aws::String&& value) { m_secretAccessKeyHasBeenSet = true; m_secretAccessKey = std::move(value); }
|
||||
inline void SetSecretAccessKey(const char* value) { m_secretAccessKeyHasBeenSet = true; m_secretAccessKey.assign(value); }
|
||||
inline AwsCredentials& WithSecretAccessKey(const Aws::String& value) { SetSecretAccessKey(value); return *this;}
|
||||
inline AwsCredentials& WithSecretAccessKey(Aws::String&& value) { SetSecretAccessKey(std::move(value)); return *this;}
|
||||
inline AwsCredentials& WithSecretAccessKey(const char* value) { SetSecretAccessKey(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The token that users must pass to the service API to use the temporary
|
||||
* credentials. </p>
|
||||
*/
|
||||
inline const Aws::String& GetSessionToken() const{ return m_sessionToken; }
|
||||
inline bool SessionTokenHasBeenSet() const { return m_sessionTokenHasBeenSet; }
|
||||
inline void SetSessionToken(const Aws::String& value) { m_sessionTokenHasBeenSet = true; m_sessionToken = value; }
|
||||
inline void SetSessionToken(Aws::String&& value) { m_sessionTokenHasBeenSet = true; m_sessionToken = std::move(value); }
|
||||
inline void SetSessionToken(const char* value) { m_sessionTokenHasBeenSet = true; m_sessionToken.assign(value); }
|
||||
inline AwsCredentials& WithSessionToken(const Aws::String& value) { SetSessionToken(value); return *this;}
|
||||
inline AwsCredentials& WithSessionToken(Aws::String&& value) { SetSessionToken(std::move(value)); return *this;}
|
||||
inline AwsCredentials& WithSessionToken(const char* value) { SetSessionToken(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_accessKeyId;
|
||||
bool m_accessKeyIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_secretAccessKey;
|
||||
bool m_secretAccessKeyHasBeenSet = false;
|
||||
|
||||
Aws::String m_sessionToken;
|
||||
bool m_sessionTokenHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class BackfillMode
|
||||
{
|
||||
NOT_SET,
|
||||
AUTOMATIC,
|
||||
MANUAL
|
||||
};
|
||||
|
||||
namespace BackfillModeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API BackfillMode GetBackfillModeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForBackfillMode(BackfillMode value);
|
||||
} // namespace BackfillModeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class BalancingStrategy
|
||||
{
|
||||
NOT_SET,
|
||||
SPOT_ONLY,
|
||||
SPOT_PREFERRED,
|
||||
ON_DEMAND_ONLY
|
||||
};
|
||||
|
||||
namespace BalancingStrategyMapper
|
||||
{
|
||||
AWS_GAMELIFT_API BalancingStrategy GetBalancingStrategyForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForBalancingStrategy(BalancingStrategy value);
|
||||
} // namespace BalancingStrategyMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,222 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/BuildStatus.h>
|
||||
#include <aws/gamelift/model/OperatingSystem.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Properties describing a custom game build.</p> <p> <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All
|
||||
* APIs by task</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/Build">AWS API
|
||||
* Reference</a></p>
|
||||
*/
|
||||
class Build
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API Build();
|
||||
AWS_GAMELIFT_API Build(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Build& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the build.</p>
|
||||
*/
|
||||
inline const Aws::String& GetBuildId() const{ return m_buildId; }
|
||||
inline bool BuildIdHasBeenSet() const { return m_buildIdHasBeenSet; }
|
||||
inline void SetBuildId(const Aws::String& value) { m_buildIdHasBeenSet = true; m_buildId = value; }
|
||||
inline void SetBuildId(Aws::String&& value) { m_buildIdHasBeenSet = true; m_buildId = std::move(value); }
|
||||
inline void SetBuildId(const char* value) { m_buildIdHasBeenSet = true; m_buildId.assign(value); }
|
||||
inline Build& WithBuildId(const Aws::String& value) { SetBuildId(value); return *this;}
|
||||
inline Build& WithBuildId(Aws::String&& value) { SetBuildId(std::move(value)); return *this;}
|
||||
inline Build& WithBuildId(const char* value) { SetBuildId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to a Amazon GameLift build resource and uniquely identifies it.
|
||||
* ARNs are unique across all Regions. Format is
|
||||
* <code>arn:aws:gamelift:<region>::build/build-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912</code>.
|
||||
* In a GameLift build ARN, the resource ID matches the <i>BuildId</i> value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetBuildArn() const{ return m_buildArn; }
|
||||
inline bool BuildArnHasBeenSet() const { return m_buildArnHasBeenSet; }
|
||||
inline void SetBuildArn(const Aws::String& value) { m_buildArnHasBeenSet = true; m_buildArn = value; }
|
||||
inline void SetBuildArn(Aws::String&& value) { m_buildArnHasBeenSet = true; m_buildArn = std::move(value); }
|
||||
inline void SetBuildArn(const char* value) { m_buildArnHasBeenSet = true; m_buildArn.assign(value); }
|
||||
inline Build& WithBuildArn(const Aws::String& value) { SetBuildArn(value); return *this;}
|
||||
inline Build& WithBuildArn(Aws::String&& value) { SetBuildArn(std::move(value)); return *this;}
|
||||
inline Build& WithBuildArn(const char* value) { SetBuildArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with a build. Build names do not need
|
||||
* to be unique. It can be set using <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateBuild.html">CreateBuild</a>
|
||||
* or <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/UpdateBuild">UpdateBuild</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline Build& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline Build& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline Build& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Version information that is associated with a build or script. Version
|
||||
* strings do not need to be unique.</p>
|
||||
*/
|
||||
inline const Aws::String& GetVersion() const{ return m_version; }
|
||||
inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
|
||||
inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
|
||||
inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
|
||||
inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
|
||||
inline Build& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
|
||||
inline Build& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
|
||||
inline Build& WithVersion(const char* value) { SetVersion(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Current status of the build.</p> <p>Possible build statuses include the
|
||||
* following:</p> <ul> <li> <p> <b>INITIALIZED</b> -- A new build has been defined,
|
||||
* but no files have been uploaded. You cannot create fleets for builds that are in
|
||||
* this status. When a build is successfully created, the build status is set to
|
||||
* this value. </p> </li> <li> <p> <b>READY</b> -- The game build has been
|
||||
* successfully uploaded. You can now create new fleets for this build.</p> </li>
|
||||
* <li> <p> <b>FAILED</b> -- The game build upload failed. You cannot create new
|
||||
* fleets for this build. </p> </li> </ul>
|
||||
*/
|
||||
inline const BuildStatus& GetStatus() const{ return m_status; }
|
||||
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
|
||||
inline void SetStatus(const BuildStatus& value) { m_statusHasBeenSet = true; m_status = value; }
|
||||
inline void SetStatus(BuildStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
|
||||
inline Build& WithStatus(const BuildStatus& value) { SetStatus(value); return *this;}
|
||||
inline Build& WithStatus(BuildStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>File size of the uploaded game build, expressed in bytes. When the build
|
||||
* status is <code>INITIALIZED</code> or when using a custom Amazon S3 storage
|
||||
* location, this value is 0.</p>
|
||||
*/
|
||||
inline long long GetSizeOnDisk() const{ return m_sizeOnDisk; }
|
||||
inline bool SizeOnDiskHasBeenSet() const { return m_sizeOnDiskHasBeenSet; }
|
||||
inline void SetSizeOnDisk(long long value) { m_sizeOnDiskHasBeenSet = true; m_sizeOnDisk = value; }
|
||||
inline Build& WithSizeOnDisk(long long value) { SetSizeOnDisk(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Operating system that the game server binaries are built to run on. This
|
||||
* value determines the type of fleet resources that you can use for this
|
||||
* build.</p> <p>Amazon Linux 2 (AL2) will reach end of support on
|
||||
* 6/30/2025. See more details in the <a
|
||||
* href="https://aws.amazon.com/amazon-linux-2/faqs/">Amazon Linux 2 FAQs</a>. For
|
||||
* game servers that are hosted on AL2 and use Amazon GameLift server SDK 4.x.,
|
||||
* first update the game server build to server SDK 5.x, and then deploy to AL2023
|
||||
* instances. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html">
|
||||
* Migrate to Amazon GameLift server SDK version 5.</a> </p>
|
||||
*/
|
||||
inline const OperatingSystem& GetOperatingSystem() const{ return m_operatingSystem; }
|
||||
inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
|
||||
inline void SetOperatingSystem(const OperatingSystem& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = value; }
|
||||
inline void SetOperatingSystem(OperatingSystem&& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = std::move(value); }
|
||||
inline Build& WithOperatingSystem(const OperatingSystem& value) { SetOperatingSystem(value); return *this;}
|
||||
inline Build& WithOperatingSystem(OperatingSystem&& value) { SetOperatingSystem(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A time stamp indicating when this data object was created. Format is a number
|
||||
* expressed in Unix time as milliseconds (for example
|
||||
* <code>"1469498468.057"</code>).</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
|
||||
inline Build& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline Build& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon GameLift Server SDK version used to develop your game server.</p>
|
||||
*/
|
||||
inline const Aws::String& GetServerSdkVersion() const{ return m_serverSdkVersion; }
|
||||
inline bool ServerSdkVersionHasBeenSet() const { return m_serverSdkVersionHasBeenSet; }
|
||||
inline void SetServerSdkVersion(const Aws::String& value) { m_serverSdkVersionHasBeenSet = true; m_serverSdkVersion = value; }
|
||||
inline void SetServerSdkVersion(Aws::String&& value) { m_serverSdkVersionHasBeenSet = true; m_serverSdkVersion = std::move(value); }
|
||||
inline void SetServerSdkVersion(const char* value) { m_serverSdkVersionHasBeenSet = true; m_serverSdkVersion.assign(value); }
|
||||
inline Build& WithServerSdkVersion(const Aws::String& value) { SetServerSdkVersion(value); return *this;}
|
||||
inline Build& WithServerSdkVersion(Aws::String&& value) { SetServerSdkVersion(std::move(value)); return *this;}
|
||||
inline Build& WithServerSdkVersion(const char* value) { SetServerSdkVersion(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_buildId;
|
||||
bool m_buildIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_buildArn;
|
||||
bool m_buildArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_version;
|
||||
bool m_versionHasBeenSet = false;
|
||||
|
||||
BuildStatus m_status;
|
||||
bool m_statusHasBeenSet = false;
|
||||
|
||||
long long m_sizeOnDisk;
|
||||
bool m_sizeOnDiskHasBeenSet = false;
|
||||
|
||||
OperatingSystem m_operatingSystem;
|
||||
bool m_operatingSystemHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
bool m_creationTimeHasBeenSet = false;
|
||||
|
||||
Aws::String m_serverSdkVersion;
|
||||
bool m_serverSdkVersionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class BuildStatus
|
||||
{
|
||||
NOT_SET,
|
||||
INITIALIZED,
|
||||
READY,
|
||||
FAILED
|
||||
};
|
||||
|
||||
namespace BuildStatusMapper
|
||||
{
|
||||
AWS_GAMELIFT_API BuildStatus GetBuildStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForBuildStatus(BuildStatus value);
|
||||
} // namespace BuildStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/CertificateType.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Determines whether a TLS/SSL certificate is generated for a fleet. This
|
||||
* feature must be enabled when creating the fleet. All instances in a fleet share
|
||||
* the same certificate. The certificate can be retrieved by calling the <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk.html">Amazon
|
||||
* GameLift Server SDK</a> operation <code>GetInstanceCertificate</code>.
|
||||
* </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/CertificateConfiguration">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class CertificateConfiguration
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CertificateConfiguration();
|
||||
AWS_GAMELIFT_API CertificateConfiguration(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API CertificateConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates whether a TLS/SSL certificate is generated for a fleet. </p>
|
||||
* <p>Valid values include: </p> <ul> <li> <p> <b>GENERATED</b> -- Generate a
|
||||
* TLS/SSL certificate for this fleet.</p> </li> <li> <p> <b>DISABLED</b> --
|
||||
* (default) Do not generate a TLS/SSL certificate for this fleet. </p> </li> </ul>
|
||||
*/
|
||||
inline const CertificateType& GetCertificateType() const{ return m_certificateType; }
|
||||
inline bool CertificateTypeHasBeenSet() const { return m_certificateTypeHasBeenSet; }
|
||||
inline void SetCertificateType(const CertificateType& value) { m_certificateTypeHasBeenSet = true; m_certificateType = value; }
|
||||
inline void SetCertificateType(CertificateType&& value) { m_certificateTypeHasBeenSet = true; m_certificateType = std::move(value); }
|
||||
inline CertificateConfiguration& WithCertificateType(const CertificateType& value) { SetCertificateType(value); return *this;}
|
||||
inline CertificateConfiguration& WithCertificateType(CertificateType&& value) { SetCertificateType(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
CertificateType m_certificateType;
|
||||
bool m_certificateTypeHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class CertificateType
|
||||
{
|
||||
NOT_SET,
|
||||
DISABLED,
|
||||
GENERATED
|
||||
};
|
||||
|
||||
namespace CertificateTypeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API CertificateType GetCertificateTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForCertificateType(CertificateType value);
|
||||
} // namespace CertificateTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,65 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/FilterInstanceStatus.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p> <b>This data type is used with the Amazon GameLift FleetIQ and game server
|
||||
* groups.</b> </p> <p> Filters which game servers may be claimed when calling
|
||||
* <code>ClaimGameServer</code>. </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ClaimFilterOption">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ClaimFilterOption
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ClaimFilterOption();
|
||||
AWS_GAMELIFT_API ClaimFilterOption(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ClaimFilterOption& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>List of instance statuses that game servers may be claimed on. If provided,
|
||||
* the list must contain the <code>ACTIVE</code> status.</p>
|
||||
*/
|
||||
inline const Aws::Vector<FilterInstanceStatus>& GetInstanceStatuses() const{ return m_instanceStatuses; }
|
||||
inline bool InstanceStatusesHasBeenSet() const { return m_instanceStatusesHasBeenSet; }
|
||||
inline void SetInstanceStatuses(const Aws::Vector<FilterInstanceStatus>& value) { m_instanceStatusesHasBeenSet = true; m_instanceStatuses = value; }
|
||||
inline void SetInstanceStatuses(Aws::Vector<FilterInstanceStatus>&& value) { m_instanceStatusesHasBeenSet = true; m_instanceStatuses = std::move(value); }
|
||||
inline ClaimFilterOption& WithInstanceStatuses(const Aws::Vector<FilterInstanceStatus>& value) { SetInstanceStatuses(value); return *this;}
|
||||
inline ClaimFilterOption& WithInstanceStatuses(Aws::Vector<FilterInstanceStatus>&& value) { SetInstanceStatuses(std::move(value)); return *this;}
|
||||
inline ClaimFilterOption& AddInstanceStatuses(const FilterInstanceStatus& value) { m_instanceStatusesHasBeenSet = true; m_instanceStatuses.push_back(value); return *this; }
|
||||
inline ClaimFilterOption& AddInstanceStatuses(FilterInstanceStatus&& value) { m_instanceStatusesHasBeenSet = true; m_instanceStatuses.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<FilterInstanceStatus> m_instanceStatuses;
|
||||
bool m_instanceStatusesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,115 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ClaimFilterOption.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class ClaimGameServerRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ClaimGameServerRequest();
|
||||
|
||||
// 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 "ClaimGameServer"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the game server group where the game server is
|
||||
* running. If you are not specifying a game server to claim, this value identifies
|
||||
* where you want Amazon GameLift FleetIQ to look for an available game server to
|
||||
* claim. </p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerGroupName() const{ return m_gameServerGroupName; }
|
||||
inline bool GameServerGroupNameHasBeenSet() const { return m_gameServerGroupNameHasBeenSet; }
|
||||
inline void SetGameServerGroupName(const Aws::String& value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName = value; }
|
||||
inline void SetGameServerGroupName(Aws::String&& value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName = std::move(value); }
|
||||
inline void SetGameServerGroupName(const char* value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName.assign(value); }
|
||||
inline ClaimGameServerRequest& WithGameServerGroupName(const Aws::String& value) { SetGameServerGroupName(value); return *this;}
|
||||
inline ClaimGameServerRequest& WithGameServerGroupName(Aws::String&& value) { SetGameServerGroupName(std::move(value)); return *this;}
|
||||
inline ClaimGameServerRequest& WithGameServerGroupName(const char* value) { SetGameServerGroupName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A custom string that uniquely identifies the game server to claim. If this
|
||||
* parameter is left empty, Amazon GameLift FleetIQ searches for an available game
|
||||
* server in the specified game server group.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerId() const{ return m_gameServerId; }
|
||||
inline bool GameServerIdHasBeenSet() const { return m_gameServerIdHasBeenSet; }
|
||||
inline void SetGameServerId(const Aws::String& value) { m_gameServerIdHasBeenSet = true; m_gameServerId = value; }
|
||||
inline void SetGameServerId(Aws::String&& value) { m_gameServerIdHasBeenSet = true; m_gameServerId = std::move(value); }
|
||||
inline void SetGameServerId(const char* value) { m_gameServerIdHasBeenSet = true; m_gameServerId.assign(value); }
|
||||
inline ClaimGameServerRequest& WithGameServerId(const Aws::String& value) { SetGameServerId(value); return *this;}
|
||||
inline ClaimGameServerRequest& WithGameServerId(Aws::String&& value) { SetGameServerId(std::move(value)); return *this;}
|
||||
inline ClaimGameServerRequest& WithGameServerId(const char* value) { SetGameServerId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of custom game server properties, formatted as a single string value.
|
||||
* This data is passed to a game client or service when it requests information on
|
||||
* game servers. </p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerData() const{ return m_gameServerData; }
|
||||
inline bool GameServerDataHasBeenSet() const { return m_gameServerDataHasBeenSet; }
|
||||
inline void SetGameServerData(const Aws::String& value) { m_gameServerDataHasBeenSet = true; m_gameServerData = value; }
|
||||
inline void SetGameServerData(Aws::String&& value) { m_gameServerDataHasBeenSet = true; m_gameServerData = std::move(value); }
|
||||
inline void SetGameServerData(const char* value) { m_gameServerDataHasBeenSet = true; m_gameServerData.assign(value); }
|
||||
inline ClaimGameServerRequest& WithGameServerData(const Aws::String& value) { SetGameServerData(value); return *this;}
|
||||
inline ClaimGameServerRequest& WithGameServerData(Aws::String&& value) { SetGameServerData(std::move(value)); return *this;}
|
||||
inline ClaimGameServerRequest& WithGameServerData(const char* value) { SetGameServerData(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Object that restricts how a claimed game server is chosen.</p>
|
||||
*/
|
||||
inline const ClaimFilterOption& GetFilterOption() const{ return m_filterOption; }
|
||||
inline bool FilterOptionHasBeenSet() const { return m_filterOptionHasBeenSet; }
|
||||
inline void SetFilterOption(const ClaimFilterOption& value) { m_filterOptionHasBeenSet = true; m_filterOption = value; }
|
||||
inline void SetFilterOption(ClaimFilterOption&& value) { m_filterOptionHasBeenSet = true; m_filterOption = std::move(value); }
|
||||
inline ClaimGameServerRequest& WithFilterOption(const ClaimFilterOption& value) { SetFilterOption(value); return *this;}
|
||||
inline ClaimGameServerRequest& WithFilterOption(ClaimFilterOption&& value) { SetFilterOption(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_gameServerGroupName;
|
||||
bool m_gameServerGroupNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameServerId;
|
||||
bool m_gameServerIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameServerData;
|
||||
bool m_gameServerDataHasBeenSet = false;
|
||||
|
||||
ClaimFilterOption m_filterOption;
|
||||
bool m_filterOptionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/GameServer.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class ClaimGameServerResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ClaimGameServerResult();
|
||||
AWS_GAMELIFT_API ClaimGameServerResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API ClaimGameServerResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Object that describes the newly claimed game server.</p>
|
||||
*/
|
||||
inline const GameServer& GetGameServer() const{ return m_gameServer; }
|
||||
inline void SetGameServer(const GameServer& value) { m_gameServer = value; }
|
||||
inline void SetGameServer(GameServer&& value) { m_gameServer = std::move(value); }
|
||||
inline ClaimGameServerResult& WithGameServer(const GameServer& value) { SetGameServer(value); return *this;}
|
||||
inline ClaimGameServerResult& WithGameServer(GameServer&& value) { SetGameServer(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline ClaimGameServerResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline ClaimGameServerResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline ClaimGameServerResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
GameServer m_gameServer;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ComparisonOperatorType
|
||||
{
|
||||
NOT_SET,
|
||||
GreaterThanOrEqualToThreshold,
|
||||
GreaterThanThreshold,
|
||||
LessThanThreshold,
|
||||
LessThanOrEqualToThreshold
|
||||
};
|
||||
|
||||
namespace ComparisonOperatorTypeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ComparisonOperatorType GetComparisonOperatorTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForComparisonOperatorType(ComparisonOperatorType value);
|
||||
} // namespace ComparisonOperatorTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,339 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ComputeStatus.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/gamelift/model/OperatingSystem.h>
|
||||
#include <aws/gamelift/model/EC2InstanceType.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/ContainerAttribute.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>An Amazon GameLift compute resource for hosting your game servers. Computes
|
||||
* in an Amazon GameLift fleet differs depending on the fleet's compute type
|
||||
* property as follows: </p> <ul> <li> <p>For managed EC2 fleets, a compute is an
|
||||
* EC2 instance.</p> </li> <li> <p>For Anywhere fleets, a compute is a computing
|
||||
* resource that you provide and is registered to the fleet.</p> </li>
|
||||
* </ul><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/Compute">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class Compute
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API Compute();
|
||||
AWS_GAMELIFT_API Compute(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Compute& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet that the compute belongs to.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline Compute& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline Compute& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline Compute& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (ARN) of the fleet that the compute belongs to.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetArn() const{ return m_fleetArn; }
|
||||
inline bool FleetArnHasBeenSet() const { return m_fleetArnHasBeenSet; }
|
||||
inline void SetFleetArn(const Aws::String& value) { m_fleetArnHasBeenSet = true; m_fleetArn = value; }
|
||||
inline void SetFleetArn(Aws::String&& value) { m_fleetArnHasBeenSet = true; m_fleetArn = std::move(value); }
|
||||
inline void SetFleetArn(const char* value) { m_fleetArnHasBeenSet = true; m_fleetArn.assign(value); }
|
||||
inline Compute& WithFleetArn(const Aws::String& value) { SetFleetArn(value); return *this;}
|
||||
inline Compute& WithFleetArn(Aws::String&& value) { SetFleetArn(std::move(value)); return *this;}
|
||||
inline Compute& WithFleetArn(const char* value) { SetFleetArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label for the compute resource. For instances in a managed EC2
|
||||
* fleet, the compute name is the same value as the <code>InstanceId</code> ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetComputeName() const{ return m_computeName; }
|
||||
inline bool ComputeNameHasBeenSet() const { return m_computeNameHasBeenSet; }
|
||||
inline void SetComputeName(const Aws::String& value) { m_computeNameHasBeenSet = true; m_computeName = value; }
|
||||
inline void SetComputeName(Aws::String&& value) { m_computeNameHasBeenSet = true; m_computeName = std::move(value); }
|
||||
inline void SetComputeName(const char* value) { m_computeNameHasBeenSet = true; m_computeName.assign(value); }
|
||||
inline Compute& WithComputeName(const Aws::String& value) { SetComputeName(value); return *this;}
|
||||
inline Compute& WithComputeName(Aws::String&& value) { SetComputeName(std::move(value)); return *this;}
|
||||
inline Compute& WithComputeName(const char* value) { SetComputeName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The ARN that is assigned to a compute resource and uniquely identifies it.
|
||||
* ARNs are unique across locations. Instances in managed EC2 fleets are not
|
||||
* assigned a Compute ARN.</p>
|
||||
*/
|
||||
inline const Aws::String& GetComputeArn() const{ return m_computeArn; }
|
||||
inline bool ComputeArnHasBeenSet() const { return m_computeArnHasBeenSet; }
|
||||
inline void SetComputeArn(const Aws::String& value) { m_computeArnHasBeenSet = true; m_computeArn = value; }
|
||||
inline void SetComputeArn(Aws::String&& value) { m_computeArnHasBeenSet = true; m_computeArn = std::move(value); }
|
||||
inline void SetComputeArn(const char* value) { m_computeArnHasBeenSet = true; m_computeArn.assign(value); }
|
||||
inline Compute& WithComputeArn(const Aws::String& value) { SetComputeArn(value); return *this;}
|
||||
inline Compute& WithComputeArn(Aws::String&& value) { SetComputeArn(std::move(value)); return *this;}
|
||||
inline Compute& WithComputeArn(const char* value) { SetComputeArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The IP address of a compute resource. Amazon GameLift requires a DNS name or
|
||||
* IP address for a compute.</p>
|
||||
*/
|
||||
inline const Aws::String& GetIpAddress() const{ return m_ipAddress; }
|
||||
inline bool IpAddressHasBeenSet() const { return m_ipAddressHasBeenSet; }
|
||||
inline void SetIpAddress(const Aws::String& value) { m_ipAddressHasBeenSet = true; m_ipAddress = value; }
|
||||
inline void SetIpAddress(Aws::String&& value) { m_ipAddressHasBeenSet = true; m_ipAddress = std::move(value); }
|
||||
inline void SetIpAddress(const char* value) { m_ipAddressHasBeenSet = true; m_ipAddress.assign(value); }
|
||||
inline Compute& WithIpAddress(const Aws::String& value) { SetIpAddress(value); return *this;}
|
||||
inline Compute& WithIpAddress(Aws::String&& value) { SetIpAddress(std::move(value)); return *this;}
|
||||
inline Compute& WithIpAddress(const char* value) { SetIpAddress(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The DNS name of a compute resource. Amazon GameLift requires a DNS name or IP
|
||||
* address for a compute.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDnsName() const{ return m_dnsName; }
|
||||
inline bool DnsNameHasBeenSet() const { return m_dnsNameHasBeenSet; }
|
||||
inline void SetDnsName(const Aws::String& value) { m_dnsNameHasBeenSet = true; m_dnsName = value; }
|
||||
inline void SetDnsName(Aws::String&& value) { m_dnsNameHasBeenSet = true; m_dnsName = std::move(value); }
|
||||
inline void SetDnsName(const char* value) { m_dnsNameHasBeenSet = true; m_dnsName.assign(value); }
|
||||
inline Compute& WithDnsName(const Aws::String& value) { SetDnsName(value); return *this;}
|
||||
inline Compute& WithDnsName(Aws::String&& value) { SetDnsName(std::move(value)); return *this;}
|
||||
inline Compute& WithDnsName(const char* value) { SetDnsName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Current status of the compute. A compute must have an <code>ACTIVE</code>
|
||||
* status to host game sessions.</p>
|
||||
*/
|
||||
inline const ComputeStatus& GetComputeStatus() const{ return m_computeStatus; }
|
||||
inline bool ComputeStatusHasBeenSet() const { return m_computeStatusHasBeenSet; }
|
||||
inline void SetComputeStatus(const ComputeStatus& value) { m_computeStatusHasBeenSet = true; m_computeStatus = value; }
|
||||
inline void SetComputeStatus(ComputeStatus&& value) { m_computeStatusHasBeenSet = true; m_computeStatus = std::move(value); }
|
||||
inline Compute& WithComputeStatus(const ComputeStatus& value) { SetComputeStatus(value); return *this;}
|
||||
inline Compute& WithComputeStatus(ComputeStatus&& value) { SetComputeStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the custom location you added to the fleet that this compute
|
||||
* resource resides in.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLocation() const{ return m_location; }
|
||||
inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
|
||||
inline void SetLocation(const Aws::String& value) { m_locationHasBeenSet = true; m_location = value; }
|
||||
inline void SetLocation(Aws::String&& value) { m_locationHasBeenSet = true; m_location = std::move(value); }
|
||||
inline void SetLocation(const char* value) { m_locationHasBeenSet = true; m_location.assign(value); }
|
||||
inline Compute& WithLocation(const Aws::String& value) { SetLocation(value); return *this;}
|
||||
inline Compute& WithLocation(Aws::String&& value) { SetLocation(std::move(value)); return *this;}
|
||||
inline Compute& WithLocation(const char* value) { SetLocation(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A time stamp indicating when this data object was created. Format is a number
|
||||
* expressed in Unix time as milliseconds (for example
|
||||
* <code>"1469498468.057"</code>).</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
|
||||
inline Compute& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline Compute& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of operating system on the compute resource.</p> <p>Amazon
|
||||
* Linux 2 (AL2) will reach end of support on 6/30/2025. See more details in the <a
|
||||
* href="https://aws.amazon.com/amazon-linux-2/faqs/">Amazon Linux 2 FAQs</a>. For
|
||||
* game servers that are hosted on AL2 and use Amazon GameLift server SDK 4.x.,
|
||||
* first update the game server build to server SDK 5.x, and then deploy to AL2023
|
||||
* instances. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html">
|
||||
* Migrate to Amazon GameLift server SDK version 5.</a> </p>
|
||||
*/
|
||||
inline const OperatingSystem& GetOperatingSystem() const{ return m_operatingSystem; }
|
||||
inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
|
||||
inline void SetOperatingSystem(const OperatingSystem& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = value; }
|
||||
inline void SetOperatingSystem(OperatingSystem&& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = std::move(value); }
|
||||
inline Compute& WithOperatingSystem(const OperatingSystem& value) { SetOperatingSystem(value); return *this;}
|
||||
inline Compute& WithOperatingSystem(OperatingSystem&& value) { SetOperatingSystem(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon EC2 instance type that the fleet uses. For registered computes in
|
||||
* an Amazon GameLift Anywhere fleet, this property is empty. </p>
|
||||
*/
|
||||
inline const EC2InstanceType& GetType() const{ return m_type; }
|
||||
inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
|
||||
inline void SetType(const EC2InstanceType& value) { m_typeHasBeenSet = true; m_type = value; }
|
||||
inline void SetType(EC2InstanceType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
|
||||
inline Compute& WithType(const EC2InstanceType& value) { SetType(value); return *this;}
|
||||
inline Compute& WithType(EC2InstanceType&& value) { SetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon GameLift SDK endpoint connection for a registered compute resource
|
||||
* in an Anywhere fleet. The game servers on the compute use this endpoint to
|
||||
* connect to the Amazon GameLift service.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameLiftServiceSdkEndpoint() const{ return m_gameLiftServiceSdkEndpoint; }
|
||||
inline bool GameLiftServiceSdkEndpointHasBeenSet() const { return m_gameLiftServiceSdkEndpointHasBeenSet; }
|
||||
inline void SetGameLiftServiceSdkEndpoint(const Aws::String& value) { m_gameLiftServiceSdkEndpointHasBeenSet = true; m_gameLiftServiceSdkEndpoint = value; }
|
||||
inline void SetGameLiftServiceSdkEndpoint(Aws::String&& value) { m_gameLiftServiceSdkEndpointHasBeenSet = true; m_gameLiftServiceSdkEndpoint = std::move(value); }
|
||||
inline void SetGameLiftServiceSdkEndpoint(const char* value) { m_gameLiftServiceSdkEndpointHasBeenSet = true; m_gameLiftServiceSdkEndpoint.assign(value); }
|
||||
inline Compute& WithGameLiftServiceSdkEndpoint(const Aws::String& value) { SetGameLiftServiceSdkEndpoint(value); return *this;}
|
||||
inline Compute& WithGameLiftServiceSdkEndpoint(Aws::String&& value) { SetGameLiftServiceSdkEndpoint(std::move(value)); return *this;}
|
||||
inline Compute& WithGameLiftServiceSdkEndpoint(const char* value) { SetGameLiftServiceSdkEndpoint(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> The endpoint of the Amazon GameLift Agent. </p>
|
||||
*/
|
||||
inline const Aws::String& GetGameLiftAgentEndpoint() const{ return m_gameLiftAgentEndpoint; }
|
||||
inline bool GameLiftAgentEndpointHasBeenSet() const { return m_gameLiftAgentEndpointHasBeenSet; }
|
||||
inline void SetGameLiftAgentEndpoint(const Aws::String& value) { m_gameLiftAgentEndpointHasBeenSet = true; m_gameLiftAgentEndpoint = value; }
|
||||
inline void SetGameLiftAgentEndpoint(Aws::String&& value) { m_gameLiftAgentEndpointHasBeenSet = true; m_gameLiftAgentEndpoint = std::move(value); }
|
||||
inline void SetGameLiftAgentEndpoint(const char* value) { m_gameLiftAgentEndpointHasBeenSet = true; m_gameLiftAgentEndpoint.assign(value); }
|
||||
inline Compute& WithGameLiftAgentEndpoint(const Aws::String& value) { SetGameLiftAgentEndpoint(value); return *this;}
|
||||
inline Compute& WithGameLiftAgentEndpoint(Aws::String&& value) { SetGameLiftAgentEndpoint(std::move(value)); return *this;}
|
||||
inline Compute& WithGameLiftAgentEndpoint(const char* value) { SetGameLiftAgentEndpoint(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> The <code>InstanceID</code> of the EC2 instance that is hosting the compute.
|
||||
* </p>
|
||||
*/
|
||||
inline const Aws::String& GetInstanceId() const{ return m_instanceId; }
|
||||
inline bool InstanceIdHasBeenSet() const { return m_instanceIdHasBeenSet; }
|
||||
inline void SetInstanceId(const Aws::String& value) { m_instanceIdHasBeenSet = true; m_instanceId = value; }
|
||||
inline void SetInstanceId(Aws::String&& value) { m_instanceIdHasBeenSet = true; m_instanceId = std::move(value); }
|
||||
inline void SetInstanceId(const char* value) { m_instanceIdHasBeenSet = true; m_instanceId.assign(value); }
|
||||
inline Compute& WithInstanceId(const Aws::String& value) { SetInstanceId(value); return *this;}
|
||||
inline Compute& WithInstanceId(Aws::String&& value) { SetInstanceId(std::move(value)); return *this;}
|
||||
inline Compute& WithInstanceId(const char* value) { SetInstanceId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of attributes for each container in the compute. </p>
|
||||
*/
|
||||
inline const Aws::Vector<ContainerAttribute>& GetContainerAttributes() const{ return m_containerAttributes; }
|
||||
inline bool ContainerAttributesHasBeenSet() const { return m_containerAttributesHasBeenSet; }
|
||||
inline void SetContainerAttributes(const Aws::Vector<ContainerAttribute>& value) { m_containerAttributesHasBeenSet = true; m_containerAttributes = value; }
|
||||
inline void SetContainerAttributes(Aws::Vector<ContainerAttribute>&& value) { m_containerAttributesHasBeenSet = true; m_containerAttributes = std::move(value); }
|
||||
inline Compute& WithContainerAttributes(const Aws::Vector<ContainerAttribute>& value) { SetContainerAttributes(value); return *this;}
|
||||
inline Compute& WithContainerAttributes(Aws::Vector<ContainerAttribute>&& value) { SetContainerAttributes(std::move(value)); return *this;}
|
||||
inline Compute& AddContainerAttributes(const ContainerAttribute& value) { m_containerAttributesHasBeenSet = true; m_containerAttributes.push_back(value); return *this; }
|
||||
inline Compute& AddContainerAttributes(ContainerAttribute&& value) { m_containerAttributesHasBeenSet = true; m_containerAttributes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The game server container group definition for the compute.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerContainerGroupDefinitionArn() const{ return m_gameServerContainerGroupDefinitionArn; }
|
||||
inline bool GameServerContainerGroupDefinitionArnHasBeenSet() const { return m_gameServerContainerGroupDefinitionArnHasBeenSet; }
|
||||
inline void SetGameServerContainerGroupDefinitionArn(const Aws::String& value) { m_gameServerContainerGroupDefinitionArnHasBeenSet = true; m_gameServerContainerGroupDefinitionArn = value; }
|
||||
inline void SetGameServerContainerGroupDefinitionArn(Aws::String&& value) { m_gameServerContainerGroupDefinitionArnHasBeenSet = true; m_gameServerContainerGroupDefinitionArn = std::move(value); }
|
||||
inline void SetGameServerContainerGroupDefinitionArn(const char* value) { m_gameServerContainerGroupDefinitionArnHasBeenSet = true; m_gameServerContainerGroupDefinitionArn.assign(value); }
|
||||
inline Compute& WithGameServerContainerGroupDefinitionArn(const Aws::String& value) { SetGameServerContainerGroupDefinitionArn(value); return *this;}
|
||||
inline Compute& WithGameServerContainerGroupDefinitionArn(Aws::String&& value) { SetGameServerContainerGroupDefinitionArn(std::move(value)); return *this;}
|
||||
inline Compute& WithGameServerContainerGroupDefinitionArn(const char* value) { SetGameServerContainerGroupDefinitionArn(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_fleetArn;
|
||||
bool m_fleetArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_computeName;
|
||||
bool m_computeNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_computeArn;
|
||||
bool m_computeArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_ipAddress;
|
||||
bool m_ipAddressHasBeenSet = false;
|
||||
|
||||
Aws::String m_dnsName;
|
||||
bool m_dnsNameHasBeenSet = false;
|
||||
|
||||
ComputeStatus m_computeStatus;
|
||||
bool m_computeStatusHasBeenSet = false;
|
||||
|
||||
Aws::String m_location;
|
||||
bool m_locationHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
bool m_creationTimeHasBeenSet = false;
|
||||
|
||||
OperatingSystem m_operatingSystem;
|
||||
bool m_operatingSystemHasBeenSet = false;
|
||||
|
||||
EC2InstanceType m_type;
|
||||
bool m_typeHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameLiftServiceSdkEndpoint;
|
||||
bool m_gameLiftServiceSdkEndpointHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameLiftAgentEndpoint;
|
||||
bool m_gameLiftAgentEndpointHasBeenSet = false;
|
||||
|
||||
Aws::String m_instanceId;
|
||||
bool m_instanceIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<ContainerAttribute> m_containerAttributes;
|
||||
bool m_containerAttributesHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameServerContainerGroupDefinitionArn;
|
||||
bool m_gameServerContainerGroupDefinitionArnHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ComputeStatus
|
||||
{
|
||||
NOT_SET,
|
||||
PENDING,
|
||||
ACTIVE,
|
||||
TERMINATING,
|
||||
IMPAIRED
|
||||
};
|
||||
|
||||
namespace ComputeStatusMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ComputeStatus GetComputeStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForComputeStatus(ComputeStatus value);
|
||||
} // namespace ComputeStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ComputeType
|
||||
{
|
||||
NOT_SET,
|
||||
EC2,
|
||||
ANYWHERE
|
||||
};
|
||||
|
||||
namespace ComputeTypeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ComputeType GetComputeTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForComputeType(ComputeType value);
|
||||
} // namespace ComputeTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The set of port numbers to open on each instance in a container fleet.
|
||||
* Connection ports are used by inbound traffic to connect with processes that are
|
||||
* running in containers on the fleet.</p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ConnectionPortRange">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ConnectionPortRange
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ConnectionPortRange();
|
||||
AWS_GAMELIFT_API ConnectionPortRange(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ConnectionPortRange& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Starting value for the port range.</p>
|
||||
*/
|
||||
inline int GetFromPort() const{ return m_fromPort; }
|
||||
inline bool FromPortHasBeenSet() const { return m_fromPortHasBeenSet; }
|
||||
inline void SetFromPort(int value) { m_fromPortHasBeenSet = true; m_fromPort = value; }
|
||||
inline ConnectionPortRange& WithFromPort(int value) { SetFromPort(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Ending value for the port. Port numbers are end-inclusive. This value must be
|
||||
* equal to or greater than <code>FromPort</code>.</p>
|
||||
*/
|
||||
inline int GetToPort() const{ return m_toPort; }
|
||||
inline bool ToPortHasBeenSet() const { return m_toPortHasBeenSet; }
|
||||
inline void SetToPort(int value) { m_toPortHasBeenSet = true; m_toPort = value; }
|
||||
inline ConnectionPortRange& WithToPort(int value) { SetToPort(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
int m_fromPort;
|
||||
bool m_fromPortHasBeenSet = false;
|
||||
|
||||
int m_toPort;
|
||||
bool m_toPortHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,80 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>A unique identifier for a container in a container fleet compute. </p> <p>
|
||||
* <b>Returned by:</b> <a>DescribeCompute</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerAttribute">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerAttribute
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerAttribute();
|
||||
AWS_GAMELIFT_API ContainerAttribute(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerAttribute& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The identifier for a container that's running in a compute. </p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerName() const{ return m_containerName; }
|
||||
inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
|
||||
inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
|
||||
inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
|
||||
inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
|
||||
inline ContainerAttribute& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
|
||||
inline ContainerAttribute& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
|
||||
inline ContainerAttribute& WithContainerName(const char* value) { SetContainerName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The runtime ID for the container that's running in a compute. This value is
|
||||
* unique within the compute.</p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerRuntimeId() const{ return m_containerRuntimeId; }
|
||||
inline bool ContainerRuntimeIdHasBeenSet() const { return m_containerRuntimeIdHasBeenSet; }
|
||||
inline void SetContainerRuntimeId(const Aws::String& value) { m_containerRuntimeIdHasBeenSet = true; m_containerRuntimeId = value; }
|
||||
inline void SetContainerRuntimeId(Aws::String&& value) { m_containerRuntimeIdHasBeenSet = true; m_containerRuntimeId = std::move(value); }
|
||||
inline void SetContainerRuntimeId(const char* value) { m_containerRuntimeIdHasBeenSet = true; m_containerRuntimeId.assign(value); }
|
||||
inline ContainerAttribute& WithContainerRuntimeId(const Aws::String& value) { SetContainerRuntimeId(value); return *this;}
|
||||
inline ContainerAttribute& WithContainerRuntimeId(Aws::String&& value) { SetContainerRuntimeId(std::move(value)); return *this;}
|
||||
inline ContainerAttribute& WithContainerRuntimeId(const char* value) { SetContainerRuntimeId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_containerName;
|
||||
bool m_containerNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_containerRuntimeId;
|
||||
bool m_containerRuntimeIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ContainerDependencyCondition.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>A container's dependency on another container in the same container group.
|
||||
* The dependency impacts how the dependent container is able to start or shut down
|
||||
* based the status of the other container.</p> <p>For example, <i>ContainerA</i>
|
||||
* is configured with the following dependency: a <code>START</code> dependency on
|
||||
* <i>ContainerB</i>. This means that <i>ContainerA</i> can't start until
|
||||
* <i>ContainerB</i> has started. It also means that <i>ContainerA</i> must shut
|
||||
* down before <i>ContainerB</i>.</p>
|
||||
* <p>eiifcbfhgrdurhnucnufkgbnbnnerrvbtjvljdetkehc<b>Part of:</b>
|
||||
* <a>GameServerContainerDefinition</a>, <a>GameServerContainerDefinitionInput</a>,
|
||||
* <a>SupportContainerDefinition</a>, <a>SupportContainerDefinitionInput</a>
|
||||
* </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerDependency">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerDependency
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerDependency();
|
||||
AWS_GAMELIFT_API ContainerDependency(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerDependency& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label for the container definition that this container depends
|
||||
* on.</p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerName() const{ return m_containerName; }
|
||||
inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
|
||||
inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
|
||||
inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
|
||||
inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
|
||||
inline ContainerDependency& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
|
||||
inline ContainerDependency& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
|
||||
inline ContainerDependency& WithContainerName(const char* value) { SetContainerName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The condition that the dependency container must reach before the dependent
|
||||
* container can start. Valid conditions include: </p> <ul> <li> <p>START - The
|
||||
* dependency container must have started. </p> </li> <li> <p>COMPLETE - The
|
||||
* dependency container has run to completion (exits). Use this condition with
|
||||
* nonessential containers, such as those that run a script and then exit. The
|
||||
* dependency container can't be an essential container. </p> </li> <li> <p>SUCCESS
|
||||
* - The dependency container has run to completion and exited with a zero status.
|
||||
* The dependency container can't be an essential container. </p> </li> <li>
|
||||
* <p>HEALTHY - The dependency container has passed its Docker health check. Use
|
||||
* this condition with dependency containers that have health checks configured.
|
||||
* This condition is confirmed at container group startup only.</p> </li> </ul>
|
||||
*/
|
||||
inline const ContainerDependencyCondition& GetCondition() const{ return m_condition; }
|
||||
inline bool ConditionHasBeenSet() const { return m_conditionHasBeenSet; }
|
||||
inline void SetCondition(const ContainerDependencyCondition& value) { m_conditionHasBeenSet = true; m_condition = value; }
|
||||
inline void SetCondition(ContainerDependencyCondition&& value) { m_conditionHasBeenSet = true; m_condition = std::move(value); }
|
||||
inline ContainerDependency& WithCondition(const ContainerDependencyCondition& value) { SetCondition(value); return *this;}
|
||||
inline ContainerDependency& WithCondition(ContainerDependencyCondition&& value) { SetCondition(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_containerName;
|
||||
bool m_containerNameHasBeenSet = false;
|
||||
|
||||
ContainerDependencyCondition m_condition;
|
||||
bool m_conditionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerDependencyCondition
|
||||
{
|
||||
NOT_SET,
|
||||
START,
|
||||
COMPLETE,
|
||||
SUCCESS,
|
||||
HEALTHY
|
||||
};
|
||||
|
||||
namespace ContainerDependencyConditionMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerDependencyCondition GetContainerDependencyConditionForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerDependencyCondition(ContainerDependencyCondition value);
|
||||
} // namespace ContainerDependencyConditionMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,81 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>An environment variable to set inside a container, in the form of a key-value
|
||||
* pair. </p> <p> <b>Part of:</b> <a>GameServerContainerDefinition</a>,
|
||||
* <a>GameServerContainerDefinitionInput</a>, <a>SupportContainerDefinition</a>,
|
||||
* <a>SupportContainerDefinitionInput</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerEnvironment">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerEnvironment
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerEnvironment();
|
||||
AWS_GAMELIFT_API ContainerEnvironment(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerEnvironment& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The environment variable name.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline ContainerEnvironment& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline ContainerEnvironment& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline ContainerEnvironment& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The environment variable value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetValue() const{ return m_value; }
|
||||
inline bool ValueHasBeenSet() const { return m_valueHasBeenSet; }
|
||||
inline void SetValue(const Aws::String& value) { m_valueHasBeenSet = true; m_value = value; }
|
||||
inline void SetValue(Aws::String&& value) { m_valueHasBeenSet = true; m_value = std::move(value); }
|
||||
inline void SetValue(const char* value) { m_valueHasBeenSet = true; m_value.assign(value); }
|
||||
inline ContainerEnvironment& WithValue(const Aws::String& value) { SetValue(value); return *this;}
|
||||
inline ContainerEnvironment& WithValue(Aws::String&& value) { SetValue(std::move(value)); return *this;}
|
||||
inline ContainerEnvironment& WithValue(const char* value) { SetValue(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_value;
|
||||
bool m_valueHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,464 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ConnectionPortRange.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/ContainerFleetBillingType.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/gamelift/model/ProtectionPolicy.h>
|
||||
#include <aws/gamelift/model/GameSessionCreationLimitPolicy.h>
|
||||
#include <aws/gamelift/model/ContainerFleetStatus.h>
|
||||
#include <aws/gamelift/model/DeploymentDetails.h>
|
||||
#include <aws/gamelift/model/LogConfiguration.h>
|
||||
#include <aws/gamelift/model/IpPermission.h>
|
||||
#include <aws/gamelift/model/ContainerFleetLocationAttributes.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Describes an Amazon GameLift managed container fleet. </p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerFleet">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerFleet
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerFleet();
|
||||
AWS_GAMELIFT_API ContainerFleet(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerFleet& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the container fleet to retrieve. </p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline ContainerFleet& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline ContainerFleet& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to a Amazon GameLift fleet resource and uniquely identifies it.
|
||||
* ARNs are unique across all Regions. Format is
|
||||
* <code>arn:aws:gamelift:<region>::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912</code>.
|
||||
* In a GameLift fleet ARN, the resource ID matches the <code>FleetId</code>
|
||||
* value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetArn() const{ return m_fleetArn; }
|
||||
inline bool FleetArnHasBeenSet() const { return m_fleetArnHasBeenSet; }
|
||||
inline void SetFleetArn(const Aws::String& value) { m_fleetArnHasBeenSet = true; m_fleetArn = value; }
|
||||
inline void SetFleetArn(Aws::String&& value) { m_fleetArnHasBeenSet = true; m_fleetArn = std::move(value); }
|
||||
inline void SetFleetArn(const char* value) { m_fleetArnHasBeenSet = true; m_fleetArn.assign(value); }
|
||||
inline ContainerFleet& WithFleetArn(const Aws::String& value) { SetFleetArn(value); return *this;}
|
||||
inline ContainerFleet& WithFleetArn(Aws::String&& value) { SetFleetArn(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithFleetArn(const char* value) { SetFleetArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for an Identity and Access Management (IAM) role with
|
||||
* permissions to run your containers on resources that are managed by Amazon
|
||||
* GameLift. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/setting-up-role.html">Set
|
||||
* up an IAM service role</a>. This fleet property can't be changed.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetRoleArn() const{ return m_fleetRoleArn; }
|
||||
inline bool FleetRoleArnHasBeenSet() const { return m_fleetRoleArnHasBeenSet; }
|
||||
inline void SetFleetRoleArn(const Aws::String& value) { m_fleetRoleArnHasBeenSet = true; m_fleetRoleArn = value; }
|
||||
inline void SetFleetRoleArn(Aws::String&& value) { m_fleetRoleArnHasBeenSet = true; m_fleetRoleArn = std::move(value); }
|
||||
inline void SetFleetRoleArn(const char* value) { m_fleetRoleArnHasBeenSet = true; m_fleetRoleArn.assign(value); }
|
||||
inline ContainerFleet& WithFleetRoleArn(const Aws::String& value) { SetFleetRoleArn(value); return *this;}
|
||||
inline ContainerFleet& WithFleetRoleArn(Aws::String&& value) { SetFleetRoleArn(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithFleetRoleArn(const char* value) { SetFleetRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the fleet's game server container group definition, which
|
||||
* describes how to deploy containers with your game server build and support
|
||||
* software onto each fleet instance. </p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerContainerGroupDefinitionName() const{ return m_gameServerContainerGroupDefinitionName; }
|
||||
inline bool GameServerContainerGroupDefinitionNameHasBeenSet() const { return m_gameServerContainerGroupDefinitionNameHasBeenSet; }
|
||||
inline void SetGameServerContainerGroupDefinitionName(const Aws::String& value) { m_gameServerContainerGroupDefinitionNameHasBeenSet = true; m_gameServerContainerGroupDefinitionName = value; }
|
||||
inline void SetGameServerContainerGroupDefinitionName(Aws::String&& value) { m_gameServerContainerGroupDefinitionNameHasBeenSet = true; m_gameServerContainerGroupDefinitionName = std::move(value); }
|
||||
inline void SetGameServerContainerGroupDefinitionName(const char* value) { m_gameServerContainerGroupDefinitionNameHasBeenSet = true; m_gameServerContainerGroupDefinitionName.assign(value); }
|
||||
inline ContainerFleet& WithGameServerContainerGroupDefinitionName(const Aws::String& value) { SetGameServerContainerGroupDefinitionName(value); return *this;}
|
||||
inline ContainerFleet& WithGameServerContainerGroupDefinitionName(Aws::String&& value) { SetGameServerContainerGroupDefinitionName(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithGameServerContainerGroupDefinitionName(const char* value) { SetGameServerContainerGroupDefinitionName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to the fleet's game server container group. The ARN value also
|
||||
* identifies the specific container group definition version in use.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerContainerGroupDefinitionArn() const{ return m_gameServerContainerGroupDefinitionArn; }
|
||||
inline bool GameServerContainerGroupDefinitionArnHasBeenSet() const { return m_gameServerContainerGroupDefinitionArnHasBeenSet; }
|
||||
inline void SetGameServerContainerGroupDefinitionArn(const Aws::String& value) { m_gameServerContainerGroupDefinitionArnHasBeenSet = true; m_gameServerContainerGroupDefinitionArn = value; }
|
||||
inline void SetGameServerContainerGroupDefinitionArn(Aws::String&& value) { m_gameServerContainerGroupDefinitionArnHasBeenSet = true; m_gameServerContainerGroupDefinitionArn = std::move(value); }
|
||||
inline void SetGameServerContainerGroupDefinitionArn(const char* value) { m_gameServerContainerGroupDefinitionArnHasBeenSet = true; m_gameServerContainerGroupDefinitionArn.assign(value); }
|
||||
inline ContainerFleet& WithGameServerContainerGroupDefinitionArn(const Aws::String& value) { SetGameServerContainerGroupDefinitionArn(value); return *this;}
|
||||
inline ContainerFleet& WithGameServerContainerGroupDefinitionArn(Aws::String&& value) { SetGameServerContainerGroupDefinitionArn(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithGameServerContainerGroupDefinitionArn(const char* value) { SetGameServerContainerGroupDefinitionArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of the fleet's per-instance container group definition. </p>
|
||||
*/
|
||||
inline const Aws::String& GetPerInstanceContainerGroupDefinitionName() const{ return m_perInstanceContainerGroupDefinitionName; }
|
||||
inline bool PerInstanceContainerGroupDefinitionNameHasBeenSet() const { return m_perInstanceContainerGroupDefinitionNameHasBeenSet; }
|
||||
inline void SetPerInstanceContainerGroupDefinitionName(const Aws::String& value) { m_perInstanceContainerGroupDefinitionNameHasBeenSet = true; m_perInstanceContainerGroupDefinitionName = value; }
|
||||
inline void SetPerInstanceContainerGroupDefinitionName(Aws::String&& value) { m_perInstanceContainerGroupDefinitionNameHasBeenSet = true; m_perInstanceContainerGroupDefinitionName = std::move(value); }
|
||||
inline void SetPerInstanceContainerGroupDefinitionName(const char* value) { m_perInstanceContainerGroupDefinitionNameHasBeenSet = true; m_perInstanceContainerGroupDefinitionName.assign(value); }
|
||||
inline ContainerFleet& WithPerInstanceContainerGroupDefinitionName(const Aws::String& value) { SetPerInstanceContainerGroupDefinitionName(value); return *this;}
|
||||
inline ContainerFleet& WithPerInstanceContainerGroupDefinitionName(Aws::String&& value) { SetPerInstanceContainerGroupDefinitionName(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithPerInstanceContainerGroupDefinitionName(const char* value) { SetPerInstanceContainerGroupDefinitionName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to the fleet's per-instance container group. The ARN value also
|
||||
* identifies the specific container group definition version in use.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPerInstanceContainerGroupDefinitionArn() const{ return m_perInstanceContainerGroupDefinitionArn; }
|
||||
inline bool PerInstanceContainerGroupDefinitionArnHasBeenSet() const { return m_perInstanceContainerGroupDefinitionArnHasBeenSet; }
|
||||
inline void SetPerInstanceContainerGroupDefinitionArn(const Aws::String& value) { m_perInstanceContainerGroupDefinitionArnHasBeenSet = true; m_perInstanceContainerGroupDefinitionArn = value; }
|
||||
inline void SetPerInstanceContainerGroupDefinitionArn(Aws::String&& value) { m_perInstanceContainerGroupDefinitionArnHasBeenSet = true; m_perInstanceContainerGroupDefinitionArn = std::move(value); }
|
||||
inline void SetPerInstanceContainerGroupDefinitionArn(const char* value) { m_perInstanceContainerGroupDefinitionArnHasBeenSet = true; m_perInstanceContainerGroupDefinitionArn.assign(value); }
|
||||
inline ContainerFleet& WithPerInstanceContainerGroupDefinitionArn(const Aws::String& value) { SetPerInstanceContainerGroupDefinitionArn(value); return *this;}
|
||||
inline ContainerFleet& WithPerInstanceContainerGroupDefinitionArn(Aws::String&& value) { SetPerInstanceContainerGroupDefinitionArn(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithPerInstanceContainerGroupDefinitionArn(const char* value) { SetPerInstanceContainerGroupDefinitionArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const ConnectionPortRange& GetInstanceConnectionPortRange() const{ return m_instanceConnectionPortRange; }
|
||||
inline bool InstanceConnectionPortRangeHasBeenSet() const { return m_instanceConnectionPortRangeHasBeenSet; }
|
||||
inline void SetInstanceConnectionPortRange(const ConnectionPortRange& value) { m_instanceConnectionPortRangeHasBeenSet = true; m_instanceConnectionPortRange = value; }
|
||||
inline void SetInstanceConnectionPortRange(ConnectionPortRange&& value) { m_instanceConnectionPortRangeHasBeenSet = true; m_instanceConnectionPortRange = std::move(value); }
|
||||
inline ContainerFleet& WithInstanceConnectionPortRange(const ConnectionPortRange& value) { SetInstanceConnectionPortRange(value); return *this;}
|
||||
inline ContainerFleet& WithInstanceConnectionPortRange(ConnectionPortRange&& value) { SetInstanceConnectionPortRange(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The IP address ranges and port settings that allow inbound traffic to access
|
||||
* game server processes and other processes on this fleet. </p>
|
||||
*/
|
||||
inline const Aws::Vector<IpPermission>& GetInstanceInboundPermissions() const{ return m_instanceInboundPermissions; }
|
||||
inline bool InstanceInboundPermissionsHasBeenSet() const { return m_instanceInboundPermissionsHasBeenSet; }
|
||||
inline void SetInstanceInboundPermissions(const Aws::Vector<IpPermission>& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions = value; }
|
||||
inline void SetInstanceInboundPermissions(Aws::Vector<IpPermission>&& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions = std::move(value); }
|
||||
inline ContainerFleet& WithInstanceInboundPermissions(const Aws::Vector<IpPermission>& value) { SetInstanceInboundPermissions(value); return *this;}
|
||||
inline ContainerFleet& WithInstanceInboundPermissions(Aws::Vector<IpPermission>&& value) { SetInstanceInboundPermissions(std::move(value)); return *this;}
|
||||
inline ContainerFleet& AddInstanceInboundPermissions(const IpPermission& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions.push_back(value); return *this; }
|
||||
inline ContainerFleet& AddInstanceInboundPermissions(IpPermission&& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of times to replicate the game server container group on each
|
||||
* fleet instance. </p>
|
||||
*/
|
||||
inline int GetGameServerContainerGroupsPerInstance() const{ return m_gameServerContainerGroupsPerInstance; }
|
||||
inline bool GameServerContainerGroupsPerInstanceHasBeenSet() const { return m_gameServerContainerGroupsPerInstanceHasBeenSet; }
|
||||
inline void SetGameServerContainerGroupsPerInstance(int value) { m_gameServerContainerGroupsPerInstanceHasBeenSet = true; m_gameServerContainerGroupsPerInstance = value; }
|
||||
inline ContainerFleet& WithGameServerContainerGroupsPerInstance(int value) { SetGameServerContainerGroupsPerInstance(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The calculated maximum number of game server container group that can be
|
||||
* deployed on each fleet instance. The calculation depends on the resource needs
|
||||
* of the container group and the CPU and memory resources of the fleet's instance
|
||||
* type.</p>
|
||||
*/
|
||||
inline int GetMaximumGameServerContainerGroupsPerInstance() const{ return m_maximumGameServerContainerGroupsPerInstance; }
|
||||
inline bool MaximumGameServerContainerGroupsPerInstanceHasBeenSet() const { return m_maximumGameServerContainerGroupsPerInstanceHasBeenSet; }
|
||||
inline void SetMaximumGameServerContainerGroupsPerInstance(int value) { m_maximumGameServerContainerGroupsPerInstanceHasBeenSet = true; m_maximumGameServerContainerGroupsPerInstance = value; }
|
||||
inline ContainerFleet& WithMaximumGameServerContainerGroupsPerInstance(int value) { SetMaximumGameServerContainerGroupsPerInstance(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon EC2 instance type to use for all instances in the fleet. Instance
|
||||
* type determines the computing resources and processing power that's available to
|
||||
* host your game servers. This includes including CPU, memory, storage, and
|
||||
* networking capacity. You can't update this fleet property.</p>
|
||||
*/
|
||||
inline const Aws::String& GetInstanceType() const{ return m_instanceType; }
|
||||
inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
|
||||
inline void SetInstanceType(const Aws::String& value) { m_instanceTypeHasBeenSet = true; m_instanceType = value; }
|
||||
inline void SetInstanceType(Aws::String&& value) { m_instanceTypeHasBeenSet = true; m_instanceType = std::move(value); }
|
||||
inline void SetInstanceType(const char* value) { m_instanceTypeHasBeenSet = true; m_instanceType.assign(value); }
|
||||
inline ContainerFleet& WithInstanceType(const Aws::String& value) { SetInstanceType(value); return *this;}
|
||||
inline ContainerFleet& WithInstanceType(Aws::String&& value) { SetInstanceType(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithInstanceType(const char* value) { SetInstanceType(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates whether the fleet uses On-Demand or Spot instances for this fleet.
|
||||
* Learn more about when to use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot">
|
||||
* On-Demand versus Spot Instances</a>. You can't update this fleet property.</p>
|
||||
* <p>By default, this property is set to <code>ON_DEMAND</code>.</p>
|
||||
*/
|
||||
inline const ContainerFleetBillingType& GetBillingType() const{ return m_billingType; }
|
||||
inline bool BillingTypeHasBeenSet() const { return m_billingTypeHasBeenSet; }
|
||||
inline void SetBillingType(const ContainerFleetBillingType& value) { m_billingTypeHasBeenSet = true; m_billingType = value; }
|
||||
inline void SetBillingType(ContainerFleetBillingType&& value) { m_billingTypeHasBeenSet = true; m_billingType = std::move(value); }
|
||||
inline ContainerFleet& WithBillingType(const ContainerFleetBillingType& value) { SetBillingType(value); return *this;}
|
||||
inline ContainerFleet& WithBillingType(ContainerFleetBillingType&& value) { SetBillingType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A meaningful description of the container fleet.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline ContainerFleet& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline ContainerFleet& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline ContainerFleet& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A time stamp indicating when this data object was created. Format is a number
|
||||
* expressed in Unix time as milliseconds (for example
|
||||
* <code>"1469498468.057"</code>).</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
|
||||
inline ContainerFleet& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline ContainerFleet& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of an Amazon Web Services CloudWatch metric group to add this fleet
|
||||
* to. Metric groups aggregate metrics for multiple fleets. </p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetMetricGroups() const{ return m_metricGroups; }
|
||||
inline bool MetricGroupsHasBeenSet() const { return m_metricGroupsHasBeenSet; }
|
||||
inline void SetMetricGroups(const Aws::Vector<Aws::String>& value) { m_metricGroupsHasBeenSet = true; m_metricGroups = value; }
|
||||
inline void SetMetricGroups(Aws::Vector<Aws::String>&& value) { m_metricGroupsHasBeenSet = true; m_metricGroups = std::move(value); }
|
||||
inline ContainerFleet& WithMetricGroups(const Aws::Vector<Aws::String>& value) { SetMetricGroups(value); return *this;}
|
||||
inline ContainerFleet& WithMetricGroups(Aws::Vector<Aws::String>&& value) { SetMetricGroups(std::move(value)); return *this;}
|
||||
inline ContainerFleet& AddMetricGroups(const Aws::String& value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(value); return *this; }
|
||||
inline ContainerFleet& AddMetricGroups(Aws::String&& value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(std::move(value)); return *this; }
|
||||
inline ContainerFleet& AddMetricGroups(const char* value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Determines whether Amazon GameLift can shut down game sessions on the fleet
|
||||
* that are actively running and hosting players. Amazon GameLift might prompt an
|
||||
* instance shutdown when scaling down fleet capacity or when retiring unhealthy
|
||||
* instances. You can also set game session protection for individual game sessions
|
||||
* using <a
|
||||
* href="gamelift/latest/apireference/API_UpdateGameSession.html">UpdateGameSession</a>.</p>
|
||||
* <ul> <li> <p> <b>NoProtection</b> -- Game sessions can be shut down during
|
||||
* active gameplay. </p> </li> <li> <p> <b>FullProtection</b> -- Game sessions in
|
||||
* <code>ACTIVE</code> status can't be shut down.</p> </li> </ul>
|
||||
*/
|
||||
inline const ProtectionPolicy& GetNewGameSessionProtectionPolicy() const{ return m_newGameSessionProtectionPolicy; }
|
||||
inline bool NewGameSessionProtectionPolicyHasBeenSet() const { return m_newGameSessionProtectionPolicyHasBeenSet; }
|
||||
inline void SetNewGameSessionProtectionPolicy(const ProtectionPolicy& value) { m_newGameSessionProtectionPolicyHasBeenSet = true; m_newGameSessionProtectionPolicy = value; }
|
||||
inline void SetNewGameSessionProtectionPolicy(ProtectionPolicy&& value) { m_newGameSessionProtectionPolicyHasBeenSet = true; m_newGameSessionProtectionPolicy = std::move(value); }
|
||||
inline ContainerFleet& WithNewGameSessionProtectionPolicy(const ProtectionPolicy& value) { SetNewGameSessionProtectionPolicy(value); return *this;}
|
||||
inline ContainerFleet& WithNewGameSessionProtectionPolicy(ProtectionPolicy&& value) { SetNewGameSessionProtectionPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A policy that limits the number of game sessions that each individual player
|
||||
* can create on instances in this fleet. The limit applies for a specified span of
|
||||
* time.</p>
|
||||
*/
|
||||
inline const GameSessionCreationLimitPolicy& GetGameSessionCreationLimitPolicy() const{ return m_gameSessionCreationLimitPolicy; }
|
||||
inline bool GameSessionCreationLimitPolicyHasBeenSet() const { return m_gameSessionCreationLimitPolicyHasBeenSet; }
|
||||
inline void SetGameSessionCreationLimitPolicy(const GameSessionCreationLimitPolicy& value) { m_gameSessionCreationLimitPolicyHasBeenSet = true; m_gameSessionCreationLimitPolicy = value; }
|
||||
inline void SetGameSessionCreationLimitPolicy(GameSessionCreationLimitPolicy&& value) { m_gameSessionCreationLimitPolicyHasBeenSet = true; m_gameSessionCreationLimitPolicy = std::move(value); }
|
||||
inline ContainerFleet& WithGameSessionCreationLimitPolicy(const GameSessionCreationLimitPolicy& value) { SetGameSessionCreationLimitPolicy(value); return *this;}
|
||||
inline ContainerFleet& WithGameSessionCreationLimitPolicy(GameSessionCreationLimitPolicy&& value) { SetGameSessionCreationLimitPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The current status of the container fleet.</p> <ul> <li> <p>
|
||||
* <code>PENDING</code> -- A new container fleet has been requested.</p> </li> <li>
|
||||
* <p> <code>CREATING</code> -- A new container fleet resource is being created.
|
||||
* </p> </li> <li> <p> <code>CREATED</code> -- A new container fleet resource has
|
||||
* been created. No fleet instances have been deployed.</p> </li> <li> <p>
|
||||
* <code>ACTIVATING</code> -- New container fleet instances are being deployed.</p>
|
||||
* </li> <li> <p> <code>ACTIVE</code> -- The container fleet has been deployed and
|
||||
* is ready to host game sessions.</p> </li> <li> <p> <code>UPDATING</code> --
|
||||
* Updates to the container fleet is being updated. A deployment is in
|
||||
* progress.</p> </li> </ul>
|
||||
*/
|
||||
inline const ContainerFleetStatus& GetStatus() const{ return m_status; }
|
||||
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
|
||||
inline void SetStatus(const ContainerFleetStatus& value) { m_statusHasBeenSet = true; m_status = value; }
|
||||
inline void SetStatus(ContainerFleetStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
|
||||
inline ContainerFleet& WithStatus(const ContainerFleetStatus& value) { SetStatus(value); return *this;}
|
||||
inline ContainerFleet& WithStatus(ContainerFleetStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Information about the most recent deployment for the container fleet.</p>
|
||||
*/
|
||||
inline const DeploymentDetails& GetDeploymentDetails() const{ return m_deploymentDetails; }
|
||||
inline bool DeploymentDetailsHasBeenSet() const { return m_deploymentDetailsHasBeenSet; }
|
||||
inline void SetDeploymentDetails(const DeploymentDetails& value) { m_deploymentDetailsHasBeenSet = true; m_deploymentDetails = value; }
|
||||
inline void SetDeploymentDetails(DeploymentDetails&& value) { m_deploymentDetailsHasBeenSet = true; m_deploymentDetails = std::move(value); }
|
||||
inline ContainerFleet& WithDeploymentDetails(const DeploymentDetails& value) { SetDeploymentDetails(value); return *this;}
|
||||
inline ContainerFleet& WithDeploymentDetails(DeploymentDetails&& value) { SetDeploymentDetails(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The method that is used to collect container logs for the fleet. Amazon
|
||||
* GameLift saves all standard output for each container in logs, including game
|
||||
* session logs. </p> <ul> <li> <p> <code>CLOUDWATCH</code> -- Send logs to an
|
||||
* Amazon CloudWatch log group that you define. Each container emits a log stream,
|
||||
* which is organized in the log group. </p> </li> <li> <p> <code>S3</code> --
|
||||
* Store logs in an Amazon S3 bucket that you define.</p> </li> <li> <p>
|
||||
* <code>NONE</code> -- Don't collect container logs.</p> </li> </ul>
|
||||
*/
|
||||
inline const LogConfiguration& GetLogConfiguration() const{ return m_logConfiguration; }
|
||||
inline bool LogConfigurationHasBeenSet() const { return m_logConfigurationHasBeenSet; }
|
||||
inline void SetLogConfiguration(const LogConfiguration& value) { m_logConfigurationHasBeenSet = true; m_logConfiguration = value; }
|
||||
inline void SetLogConfiguration(LogConfiguration&& value) { m_logConfigurationHasBeenSet = true; m_logConfiguration = std::move(value); }
|
||||
inline ContainerFleet& WithLogConfiguration(const LogConfiguration& value) { SetLogConfiguration(value); return *this;}
|
||||
inline ContainerFleet& WithLogConfiguration(LogConfiguration&& value) { SetLogConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Information about the container fleet's remote locations where fleet
|
||||
* instances are deployed.</p>
|
||||
*/
|
||||
inline const Aws::Vector<ContainerFleetLocationAttributes>& GetLocationAttributes() const{ return m_locationAttributes; }
|
||||
inline bool LocationAttributesHasBeenSet() const { return m_locationAttributesHasBeenSet; }
|
||||
inline void SetLocationAttributes(const Aws::Vector<ContainerFleetLocationAttributes>& value) { m_locationAttributesHasBeenSet = true; m_locationAttributes = value; }
|
||||
inline void SetLocationAttributes(Aws::Vector<ContainerFleetLocationAttributes>&& value) { m_locationAttributesHasBeenSet = true; m_locationAttributes = std::move(value); }
|
||||
inline ContainerFleet& WithLocationAttributes(const Aws::Vector<ContainerFleetLocationAttributes>& value) { SetLocationAttributes(value); return *this;}
|
||||
inline ContainerFleet& WithLocationAttributes(Aws::Vector<ContainerFleetLocationAttributes>&& value) { SetLocationAttributes(std::move(value)); return *this;}
|
||||
inline ContainerFleet& AddLocationAttributes(const ContainerFleetLocationAttributes& value) { m_locationAttributesHasBeenSet = true; m_locationAttributes.push_back(value); return *this; }
|
||||
inline ContainerFleet& AddLocationAttributes(ContainerFleetLocationAttributes&& value) { m_locationAttributesHasBeenSet = true; m_locationAttributes.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_fleetArn;
|
||||
bool m_fleetArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_fleetRoleArn;
|
||||
bool m_fleetRoleArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameServerContainerGroupDefinitionName;
|
||||
bool m_gameServerContainerGroupDefinitionNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameServerContainerGroupDefinitionArn;
|
||||
bool m_gameServerContainerGroupDefinitionArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_perInstanceContainerGroupDefinitionName;
|
||||
bool m_perInstanceContainerGroupDefinitionNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_perInstanceContainerGroupDefinitionArn;
|
||||
bool m_perInstanceContainerGroupDefinitionArnHasBeenSet = false;
|
||||
|
||||
ConnectionPortRange m_instanceConnectionPortRange;
|
||||
bool m_instanceConnectionPortRangeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<IpPermission> m_instanceInboundPermissions;
|
||||
bool m_instanceInboundPermissionsHasBeenSet = false;
|
||||
|
||||
int m_gameServerContainerGroupsPerInstance;
|
||||
bool m_gameServerContainerGroupsPerInstanceHasBeenSet = false;
|
||||
|
||||
int m_maximumGameServerContainerGroupsPerInstance;
|
||||
bool m_maximumGameServerContainerGroupsPerInstanceHasBeenSet = false;
|
||||
|
||||
Aws::String m_instanceType;
|
||||
bool m_instanceTypeHasBeenSet = false;
|
||||
|
||||
ContainerFleetBillingType m_billingType;
|
||||
bool m_billingTypeHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
bool m_creationTimeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_metricGroups;
|
||||
bool m_metricGroupsHasBeenSet = false;
|
||||
|
||||
ProtectionPolicy m_newGameSessionProtectionPolicy;
|
||||
bool m_newGameSessionProtectionPolicyHasBeenSet = false;
|
||||
|
||||
GameSessionCreationLimitPolicy m_gameSessionCreationLimitPolicy;
|
||||
bool m_gameSessionCreationLimitPolicyHasBeenSet = false;
|
||||
|
||||
ContainerFleetStatus m_status;
|
||||
bool m_statusHasBeenSet = false;
|
||||
|
||||
DeploymentDetails m_deploymentDetails;
|
||||
bool m_deploymentDetailsHasBeenSet = false;
|
||||
|
||||
LogConfiguration m_logConfiguration;
|
||||
bool m_logConfigurationHasBeenSet = false;
|
||||
|
||||
Aws::Vector<ContainerFleetLocationAttributes> m_locationAttributes;
|
||||
bool m_locationAttributesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerFleetBillingType
|
||||
{
|
||||
NOT_SET,
|
||||
ON_DEMAND,
|
||||
SPOT
|
||||
};
|
||||
|
||||
namespace ContainerFleetBillingTypeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerFleetBillingType GetContainerFleetBillingTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerFleetBillingType(ContainerFleetBillingType value);
|
||||
} // namespace ContainerFleetBillingTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,87 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ContainerFleetLocationStatus.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Details about a location in a multi-location container fleet. </p><p><h3>See
|
||||
* Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerFleetLocationAttributes">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerFleetLocationAttributes
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerFleetLocationAttributes();
|
||||
AWS_GAMELIFT_API ContainerFleetLocationAttributes(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerFleetLocationAttributes& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A location identifier.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLocation() const{ return m_location; }
|
||||
inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
|
||||
inline void SetLocation(const Aws::String& value) { m_locationHasBeenSet = true; m_location = value; }
|
||||
inline void SetLocation(Aws::String&& value) { m_locationHasBeenSet = true; m_location = std::move(value); }
|
||||
inline void SetLocation(const char* value) { m_locationHasBeenSet = true; m_location.assign(value); }
|
||||
inline ContainerFleetLocationAttributes& WithLocation(const Aws::String& value) { SetLocation(value); return *this;}
|
||||
inline ContainerFleetLocationAttributes& WithLocation(Aws::String&& value) { SetLocation(std::move(value)); return *this;}
|
||||
inline ContainerFleetLocationAttributes& WithLocation(const char* value) { SetLocation(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The status of fleet activity in the location. </p> <ul> <li> <p>
|
||||
* <code>PENDING</code> -- A new container fleet has been requested.</p> </li> <li>
|
||||
* <p> <code>CREATING</code> -- A new container fleet resource is being created.
|
||||
* </p> </li> <li> <p> <code>CREATED</code> -- A new container fleet resource has
|
||||
* been created. No fleet instances have been deployed.</p> </li> <li> <p>
|
||||
* <code>ACTIVATING</code> -- New container fleet instances are being deployed.</p>
|
||||
* </li> <li> <p> <code>ACTIVE</code> -- The container fleet has been deployed and
|
||||
* is ready to host game sessions.</p> </li> <li> <p> <code>UPDATING</code> --
|
||||
* Updates to the container fleet is being updated. A deployment is in
|
||||
* progress.</p> </li> </ul>
|
||||
*/
|
||||
inline const ContainerFleetLocationStatus& GetStatus() const{ return m_status; }
|
||||
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
|
||||
inline void SetStatus(const ContainerFleetLocationStatus& value) { m_statusHasBeenSet = true; m_status = value; }
|
||||
inline void SetStatus(ContainerFleetLocationStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
|
||||
inline ContainerFleetLocationAttributes& WithStatus(const ContainerFleetLocationStatus& value) { SetStatus(value); return *this;}
|
||||
inline ContainerFleetLocationAttributes& WithStatus(ContainerFleetLocationStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_location;
|
||||
bool m_locationHasBeenSet = false;
|
||||
|
||||
ContainerFleetLocationStatus m_status;
|
||||
bool m_statusHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerFleetLocationStatus
|
||||
{
|
||||
NOT_SET,
|
||||
PENDING,
|
||||
CREATING,
|
||||
CREATED,
|
||||
ACTIVATING,
|
||||
ACTIVE,
|
||||
UPDATING,
|
||||
DELETING
|
||||
};
|
||||
|
||||
namespace ContainerFleetLocationStatusMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerFleetLocationStatus GetContainerFleetLocationStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerFleetLocationStatus(ContainerFleetLocationStatus value);
|
||||
} // namespace ContainerFleetLocationStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerFleetRemoveAttribute
|
||||
{
|
||||
NOT_SET,
|
||||
PER_INSTANCE_CONTAINER_GROUP_DEFINITION
|
||||
};
|
||||
|
||||
namespace ContainerFleetRemoveAttributeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerFleetRemoveAttribute GetContainerFleetRemoveAttributeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerFleetRemoveAttribute(ContainerFleetRemoveAttribute value);
|
||||
} // namespace ContainerFleetRemoveAttributeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerFleetStatus
|
||||
{
|
||||
NOT_SET,
|
||||
PENDING,
|
||||
CREATING,
|
||||
CREATED,
|
||||
ACTIVATING,
|
||||
ACTIVE,
|
||||
UPDATING,
|
||||
DELETING
|
||||
};
|
||||
|
||||
namespace ContainerFleetStatusMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerFleetStatus GetContainerFleetStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerFleetStatus(ContainerFleetStatus value);
|
||||
} // namespace ContainerFleetStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,317 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/DateTime.h>
|
||||
#include <aws/gamelift/model/ContainerOperatingSystem.h>
|
||||
#include <aws/gamelift/model/ContainerGroupType.h>
|
||||
#include <aws/gamelift/model/GameServerContainerDefinition.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/ContainerGroupDefinitionStatus.h>
|
||||
#include <aws/gamelift/model/SupportContainerDefinition.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>The properties that describe a container group resource. You can update all
|
||||
* properties of a container group definition properties. Updates to a container
|
||||
* group definition are saved as new versions. </p> <p> <b>Used with:</b>
|
||||
* <a>CreateContainerGroupDefinition</a> </p> <p> <b>Returned by:</b>
|
||||
* <a>DescribeContainerGroupDefinition</a>, <a>ListContainerGroupDefinitions</a>,
|
||||
* <a>UpdateContainerGroupDefinition</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerGroupDefinition">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerGroupDefinition
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerGroupDefinition();
|
||||
AWS_GAMELIFT_API ContainerGroupDefinition(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerGroupDefinition& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to an Amazon GameLift <code>ContainerGroupDefinition</code>
|
||||
* resource. It uniquely identifies the resource across all Amazon Web Services
|
||||
* Regions. Format is
|
||||
* <code>arn:aws:gamelift:[region]::containergroupdefinition/[container group
|
||||
* definition name]:[version]</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerGroupDefinitionArn() const{ return m_containerGroupDefinitionArn; }
|
||||
inline bool ContainerGroupDefinitionArnHasBeenSet() const { return m_containerGroupDefinitionArnHasBeenSet; }
|
||||
inline void SetContainerGroupDefinitionArn(const Aws::String& value) { m_containerGroupDefinitionArnHasBeenSet = true; m_containerGroupDefinitionArn = value; }
|
||||
inline void SetContainerGroupDefinitionArn(Aws::String&& value) { m_containerGroupDefinitionArnHasBeenSet = true; m_containerGroupDefinitionArn = std::move(value); }
|
||||
inline void SetContainerGroupDefinitionArn(const char* value) { m_containerGroupDefinitionArnHasBeenSet = true; m_containerGroupDefinitionArn.assign(value); }
|
||||
inline ContainerGroupDefinition& WithContainerGroupDefinitionArn(const Aws::String& value) { SetContainerGroupDefinitionArn(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithContainerGroupDefinitionArn(Aws::String&& value) { SetContainerGroupDefinitionArn(std::move(value)); return *this;}
|
||||
inline ContainerGroupDefinition& WithContainerGroupDefinitionArn(const char* value) { SetContainerGroupDefinitionArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A time stamp indicating when this data object was created. Format is a number
|
||||
* expressed in Unix time as milliseconds (for example
|
||||
* <code>"1469498468.057"</code>).</p>
|
||||
*/
|
||||
inline const Aws::Utils::DateTime& GetCreationTime() const{ return m_creationTime; }
|
||||
inline bool CreationTimeHasBeenSet() const { return m_creationTimeHasBeenSet; }
|
||||
inline void SetCreationTime(const Aws::Utils::DateTime& value) { m_creationTimeHasBeenSet = true; m_creationTime = value; }
|
||||
inline void SetCreationTime(Aws::Utils::DateTime&& value) { m_creationTimeHasBeenSet = true; m_creationTime = std::move(value); }
|
||||
inline ContainerGroupDefinition& WithCreationTime(const Aws::Utils::DateTime& value) { SetCreationTime(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithCreationTime(Aws::Utils::DateTime&& value) { SetCreationTime(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The platform that all containers in the container group definition run
|
||||
* on.</p> <p>Amazon Linux 2 (AL2) will reach end of support on 6/30/2025.
|
||||
* See more details in the <a
|
||||
* href="https://aws.amazon.com/amazon-linux-2/faqs/">Amazon Linux 2 FAQs</a>. For
|
||||
* game servers that are hosted on AL2 and use Amazon GameLift server SDK 4.x,
|
||||
* first update the game server build to server SDK 5.x, and then deploy to AL2023
|
||||
* instances. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html">
|
||||
* Migrate to Amazon GameLift server SDK version 5.</a> </p>
|
||||
*/
|
||||
inline const ContainerOperatingSystem& GetOperatingSystem() const{ return m_operatingSystem; }
|
||||
inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
|
||||
inline void SetOperatingSystem(const ContainerOperatingSystem& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = value; }
|
||||
inline void SetOperatingSystem(ContainerOperatingSystem&& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = std::move(value); }
|
||||
inline ContainerGroupDefinition& WithOperatingSystem(const ContainerOperatingSystem& value) { SetOperatingSystem(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithOperatingSystem(ContainerOperatingSystem&& value) { SetOperatingSystem(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive identifier for the container group definition. The name value
|
||||
* is unique in an Amazon Web Services Region.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline ContainerGroupDefinition& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline ContainerGroupDefinition& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of container group. Container group type determines how Amazon
|
||||
* GameLift deploys the container group on each fleet instance.</p>
|
||||
*/
|
||||
inline const ContainerGroupType& GetContainerGroupType() const{ return m_containerGroupType; }
|
||||
inline bool ContainerGroupTypeHasBeenSet() const { return m_containerGroupTypeHasBeenSet; }
|
||||
inline void SetContainerGroupType(const ContainerGroupType& value) { m_containerGroupTypeHasBeenSet = true; m_containerGroupType = value; }
|
||||
inline void SetContainerGroupType(ContainerGroupType&& value) { m_containerGroupTypeHasBeenSet = true; m_containerGroupType = std::move(value); }
|
||||
inline ContainerGroupDefinition& WithContainerGroupType(const ContainerGroupType& value) { SetContainerGroupType(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithContainerGroupType(ContainerGroupType&& value) { SetContainerGroupType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The amount of memory (in MiB) on a fleet instance to allocate for the
|
||||
* container group. All containers in the group share these resources. </p> <p>You
|
||||
* can set a limit for each container definition in the group. If individual
|
||||
* containers have limits, this total value must be greater than any individual
|
||||
* container's memory limit.</p>
|
||||
*/
|
||||
inline int GetTotalMemoryLimitMebibytes() const{ return m_totalMemoryLimitMebibytes; }
|
||||
inline bool TotalMemoryLimitMebibytesHasBeenSet() const { return m_totalMemoryLimitMebibytesHasBeenSet; }
|
||||
inline void SetTotalMemoryLimitMebibytes(int value) { m_totalMemoryLimitMebibytesHasBeenSet = true; m_totalMemoryLimitMebibytes = value; }
|
||||
inline ContainerGroupDefinition& WithTotalMemoryLimitMebibytes(int value) { SetTotalMemoryLimitMebibytes(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The amount of vCPU units on a fleet instance to allocate for the container
|
||||
* group (1 vCPU is equal to 1024 CPU units). All containers in the group share
|
||||
* these resources. You can set a limit for each container definition in the group.
|
||||
* If individual containers have limits, this total value must be equal to or
|
||||
* greater than the sum of the limits for each container in the group.</p>
|
||||
*/
|
||||
inline double GetTotalVcpuLimit() const{ return m_totalVcpuLimit; }
|
||||
inline bool TotalVcpuLimitHasBeenSet() const { return m_totalVcpuLimitHasBeenSet; }
|
||||
inline void SetTotalVcpuLimit(double value) { m_totalVcpuLimitHasBeenSet = true; m_totalVcpuLimit = value; }
|
||||
inline ContainerGroupDefinition& WithTotalVcpuLimit(double value) { SetTotalVcpuLimit(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The definition for the game server container in this group. This property is
|
||||
* used only when the container group type is <code>GAME_SERVER</code>. This
|
||||
* container definition specifies a container image with the game server build.
|
||||
* </p>
|
||||
*/
|
||||
inline const GameServerContainerDefinition& GetGameServerContainerDefinition() const{ return m_gameServerContainerDefinition; }
|
||||
inline bool GameServerContainerDefinitionHasBeenSet() const { return m_gameServerContainerDefinitionHasBeenSet; }
|
||||
inline void SetGameServerContainerDefinition(const GameServerContainerDefinition& value) { m_gameServerContainerDefinitionHasBeenSet = true; m_gameServerContainerDefinition = value; }
|
||||
inline void SetGameServerContainerDefinition(GameServerContainerDefinition&& value) { m_gameServerContainerDefinitionHasBeenSet = true; m_gameServerContainerDefinition = std::move(value); }
|
||||
inline ContainerGroupDefinition& WithGameServerContainerDefinition(const GameServerContainerDefinition& value) { SetGameServerContainerDefinition(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithGameServerContainerDefinition(GameServerContainerDefinition&& value) { SetGameServerContainerDefinition(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The set of definitions for support containers in this group. A container
|
||||
* group definition might have zero support container definitions. Support
|
||||
* container can be used in any type of container group.</p>
|
||||
*/
|
||||
inline const Aws::Vector<SupportContainerDefinition>& GetSupportContainerDefinitions() const{ return m_supportContainerDefinitions; }
|
||||
inline bool SupportContainerDefinitionsHasBeenSet() const { return m_supportContainerDefinitionsHasBeenSet; }
|
||||
inline void SetSupportContainerDefinitions(const Aws::Vector<SupportContainerDefinition>& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions = value; }
|
||||
inline void SetSupportContainerDefinitions(Aws::Vector<SupportContainerDefinition>&& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions = std::move(value); }
|
||||
inline ContainerGroupDefinition& WithSupportContainerDefinitions(const Aws::Vector<SupportContainerDefinition>& value) { SetSupportContainerDefinitions(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithSupportContainerDefinitions(Aws::Vector<SupportContainerDefinition>&& value) { SetSupportContainerDefinitions(std::move(value)); return *this;}
|
||||
inline ContainerGroupDefinition& AddSupportContainerDefinitions(const SupportContainerDefinition& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions.push_back(value); return *this; }
|
||||
inline ContainerGroupDefinition& AddSupportContainerDefinitions(SupportContainerDefinition&& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates the version of a particular container group definition. This number
|
||||
* is incremented automatically when you update a container group definition. You
|
||||
* can view, update, or delete individual versions or the entire container group
|
||||
* definition.</p>
|
||||
*/
|
||||
inline int GetVersionNumber() const{ return m_versionNumber; }
|
||||
inline bool VersionNumberHasBeenSet() const { return m_versionNumberHasBeenSet; }
|
||||
inline void SetVersionNumber(int value) { m_versionNumberHasBeenSet = true; m_versionNumber = value; }
|
||||
inline ContainerGroupDefinition& WithVersionNumber(int value) { SetVersionNumber(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An optional description that was provided for a container group definition
|
||||
* update. Each version can have a unique description.</p>
|
||||
*/
|
||||
inline const Aws::String& GetVersionDescription() const{ return m_versionDescription; }
|
||||
inline bool VersionDescriptionHasBeenSet() const { return m_versionDescriptionHasBeenSet; }
|
||||
inline void SetVersionDescription(const Aws::String& value) { m_versionDescriptionHasBeenSet = true; m_versionDescription = value; }
|
||||
inline void SetVersionDescription(Aws::String&& value) { m_versionDescriptionHasBeenSet = true; m_versionDescription = std::move(value); }
|
||||
inline void SetVersionDescription(const char* value) { m_versionDescriptionHasBeenSet = true; m_versionDescription.assign(value); }
|
||||
inline ContainerGroupDefinition& WithVersionDescription(const Aws::String& value) { SetVersionDescription(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithVersionDescription(Aws::String&& value) { SetVersionDescription(std::move(value)); return *this;}
|
||||
inline ContainerGroupDefinition& WithVersionDescription(const char* value) { SetVersionDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Current status of the container group definition resource. Values
|
||||
* include:</p> <ul> <li> <p> <code>COPYING</code> -- Amazon GameLift is in the
|
||||
* process of making copies of all container images that are defined in the group.
|
||||
* While in this state, the resource can't be used to create a container fleet.</p>
|
||||
* </li> <li> <p> <code>READY</code> -- Amazon GameLift has copied the registry
|
||||
* images for all containers that are defined in the group. You can use a container
|
||||
* group definition in this status to create a container fleet. </p> </li> <li> <p>
|
||||
* <code>FAILED</code> -- Amazon GameLift failed to create a valid container group
|
||||
* definition resource. For more details on the cause of the failure, see
|
||||
* <code>StatusReason</code>. A container group definition resource in failed
|
||||
* status will be deleted within a few minutes.</p> </li> </ul>
|
||||
*/
|
||||
inline const ContainerGroupDefinitionStatus& GetStatus() const{ return m_status; }
|
||||
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
|
||||
inline void SetStatus(const ContainerGroupDefinitionStatus& value) { m_statusHasBeenSet = true; m_status = value; }
|
||||
inline void SetStatus(ContainerGroupDefinitionStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
|
||||
inline ContainerGroupDefinition& WithStatus(const ContainerGroupDefinitionStatus& value) { SetStatus(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithStatus(ContainerGroupDefinitionStatus&& value) { SetStatus(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Additional information about a container group definition that's in
|
||||
* <code>FAILED</code> status. Possible reasons include:</p> <ul> <li> <p>An
|
||||
* internal issue prevented Amazon GameLift from creating the container group
|
||||
* definition resource. Delete the failed resource and call
|
||||
* <a>CreateContainerGroupDefinition</a>again. </p> </li> <li> <p>An access-denied
|
||||
* message means that you don't have permissions to access the container image on
|
||||
* ECR. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-iam-policy-examples.html">
|
||||
* IAM permission examples</a> for help setting up required IAM permissions for
|
||||
* Amazon GameLift.</p> </li> <li> <p>The <code>ImageUri</code> value for at least
|
||||
* one of the containers in the container group definition was invalid or not found
|
||||
* in the current Amazon Web Services account.</p> </li> <li> <p>At least one of
|
||||
* the container images referenced in the container group definition exceeds the
|
||||
* allowed size. For size limits, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/gamelift.html"> Amazon
|
||||
* GameLift endpoints and quotas</a>.</p> </li> <li> <p>At least one of the
|
||||
* container images referenced in the container group definition uses a different
|
||||
* operating system than the one defined for the container group.</p> </li> </ul>
|
||||
*/
|
||||
inline const Aws::String& GetStatusReason() const{ return m_statusReason; }
|
||||
inline bool StatusReasonHasBeenSet() const { return m_statusReasonHasBeenSet; }
|
||||
inline void SetStatusReason(const Aws::String& value) { m_statusReasonHasBeenSet = true; m_statusReason = value; }
|
||||
inline void SetStatusReason(Aws::String&& value) { m_statusReasonHasBeenSet = true; m_statusReason = std::move(value); }
|
||||
inline void SetStatusReason(const char* value) { m_statusReasonHasBeenSet = true; m_statusReason.assign(value); }
|
||||
inline ContainerGroupDefinition& WithStatusReason(const Aws::String& value) { SetStatusReason(value); return *this;}
|
||||
inline ContainerGroupDefinition& WithStatusReason(Aws::String&& value) { SetStatusReason(std::move(value)); return *this;}
|
||||
inline ContainerGroupDefinition& WithStatusReason(const char* value) { SetStatusReason(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_containerGroupDefinitionArn;
|
||||
bool m_containerGroupDefinitionArnHasBeenSet = false;
|
||||
|
||||
Aws::Utils::DateTime m_creationTime;
|
||||
bool m_creationTimeHasBeenSet = false;
|
||||
|
||||
ContainerOperatingSystem m_operatingSystem;
|
||||
bool m_operatingSystemHasBeenSet = false;
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
ContainerGroupType m_containerGroupType;
|
||||
bool m_containerGroupTypeHasBeenSet = false;
|
||||
|
||||
int m_totalMemoryLimitMebibytes;
|
||||
bool m_totalMemoryLimitMebibytesHasBeenSet = false;
|
||||
|
||||
double m_totalVcpuLimit;
|
||||
bool m_totalVcpuLimitHasBeenSet = false;
|
||||
|
||||
GameServerContainerDefinition m_gameServerContainerDefinition;
|
||||
bool m_gameServerContainerDefinitionHasBeenSet = false;
|
||||
|
||||
Aws::Vector<SupportContainerDefinition> m_supportContainerDefinitions;
|
||||
bool m_supportContainerDefinitionsHasBeenSet = false;
|
||||
|
||||
int m_versionNumber;
|
||||
bool m_versionNumberHasBeenSet = false;
|
||||
|
||||
Aws::String m_versionDescription;
|
||||
bool m_versionDescriptionHasBeenSet = false;
|
||||
|
||||
ContainerGroupDefinitionStatus m_status;
|
||||
bool m_statusHasBeenSet = false;
|
||||
|
||||
Aws::String m_statusReason;
|
||||
bool m_statusReasonHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerGroupDefinitionStatus
|
||||
{
|
||||
NOT_SET,
|
||||
READY,
|
||||
COPYING,
|
||||
FAILED
|
||||
};
|
||||
|
||||
namespace ContainerGroupDefinitionStatusMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerGroupDefinitionStatus GetContainerGroupDefinitionStatusForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerGroupDefinitionStatus(ContainerGroupDefinitionStatus value);
|
||||
} // namespace ContainerGroupDefinitionStatusMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerGroupType
|
||||
{
|
||||
NOT_SET,
|
||||
GAME_SERVER,
|
||||
PER_INSTANCE
|
||||
};
|
||||
|
||||
namespace ContainerGroupTypeMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerGroupType GetContainerGroupTypeForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerGroupType(ContainerGroupType value);
|
||||
} // namespace ContainerGroupTypeMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,133 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>Instructions on when and how to check the health of a support container in a
|
||||
* container fleet. These properties override any Docker health checks that are set
|
||||
* in the container image. For more information on container health checks, see <a
|
||||
* href="https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html#ECS-Type-HealthCheck-command">HealthCheck
|
||||
* command</a> in the <i>Amazon Elastic Container Service API</i>. Game server
|
||||
* containers don't have a health check parameter; Amazon GameLift automatically
|
||||
* handles health checks for these containers.</p> <p>The following example
|
||||
* instructs the container to initiate a health check command every 60 seconds and
|
||||
* wait 10 seconds for it to succeed. If it fails, retry the command 3 times before
|
||||
* flagging the container as unhealthy. It also tells the container to wait 100
|
||||
* seconds after launch before counting failed health checks.</p> <p>
|
||||
* <code>{"Command": [ "CMD-SHELL", "ps cax | grep "processmanager" || exit 1" ],
|
||||
* "Interval": 60, "Timeout": 10, "Retries": 3, "StartPeriod": 100 }</code> </p>
|
||||
* <p> <b>Part of:</b> <a>SupportContainerDefinition</a>,
|
||||
* <a>SupportContainerDefinitionInput</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerHealthCheck">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerHealthCheck
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerHealthCheck();
|
||||
AWS_GAMELIFT_API ContainerHealthCheck(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerHealthCheck& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A string array that specifies the command that the container runs to
|
||||
* determine if it's healthy.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetCommand() const{ return m_command; }
|
||||
inline bool CommandHasBeenSet() const { return m_commandHasBeenSet; }
|
||||
inline void SetCommand(const Aws::Vector<Aws::String>& value) { m_commandHasBeenSet = true; m_command = value; }
|
||||
inline void SetCommand(Aws::Vector<Aws::String>&& value) { m_commandHasBeenSet = true; m_command = std::move(value); }
|
||||
inline ContainerHealthCheck& WithCommand(const Aws::Vector<Aws::String>& value) { SetCommand(value); return *this;}
|
||||
inline ContainerHealthCheck& WithCommand(Aws::Vector<Aws::String>&& value) { SetCommand(std::move(value)); return *this;}
|
||||
inline ContainerHealthCheck& AddCommand(const Aws::String& value) { m_commandHasBeenSet = true; m_command.push_back(value); return *this; }
|
||||
inline ContainerHealthCheck& AddCommand(Aws::String&& value) { m_commandHasBeenSet = true; m_command.push_back(std::move(value)); return *this; }
|
||||
inline ContainerHealthCheck& AddCommand(const char* value) { m_commandHasBeenSet = true; m_command.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time period (in seconds) between each health check.</p>
|
||||
*/
|
||||
inline int GetInterval() const{ return m_interval; }
|
||||
inline bool IntervalHasBeenSet() const { return m_intervalHasBeenSet; }
|
||||
inline void SetInterval(int value) { m_intervalHasBeenSet = true; m_interval = value; }
|
||||
inline ContainerHealthCheck& WithInterval(int value) { SetInterval(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of times to retry a failed health check before flagging the
|
||||
* container unhealthy. The first run of the command does not count as a retry.</p>
|
||||
*/
|
||||
inline int GetRetries() const{ return m_retries; }
|
||||
inline bool RetriesHasBeenSet() const { return m_retriesHasBeenSet; }
|
||||
inline void SetRetries(int value) { m_retriesHasBeenSet = true; m_retries = value; }
|
||||
inline ContainerHealthCheck& WithRetries(int value) { SetRetries(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The optional grace period (in seconds) to give a container time to bootstrap
|
||||
* before the first failed health check counts toward the number of retries.</p>
|
||||
*/
|
||||
inline int GetStartPeriod() const{ return m_startPeriod; }
|
||||
inline bool StartPeriodHasBeenSet() const { return m_startPeriodHasBeenSet; }
|
||||
inline void SetStartPeriod(int value) { m_startPeriodHasBeenSet = true; m_startPeriod = value; }
|
||||
inline ContainerHealthCheck& WithStartPeriod(int value) { SetStartPeriod(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The time period (in seconds) to wait for a health check to succeed before
|
||||
* counting a failed health check. </p>
|
||||
*/
|
||||
inline int GetTimeout() const{ return m_timeout; }
|
||||
inline bool TimeoutHasBeenSet() const { return m_timeoutHasBeenSet; }
|
||||
inline void SetTimeout(int value) { m_timeoutHasBeenSet = true; m_timeout = value; }
|
||||
inline ContainerHealthCheck& WithTimeout(int value) { SetTimeout(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<Aws::String> m_command;
|
||||
bool m_commandHasBeenSet = false;
|
||||
|
||||
int m_interval;
|
||||
bool m_intervalHasBeenSet = false;
|
||||
|
||||
int m_retries;
|
||||
bool m_retriesHasBeenSet = false;
|
||||
|
||||
int m_startPeriod;
|
||||
bool m_startPeriodHasBeenSet = false;
|
||||
|
||||
int m_timeout;
|
||||
bool m_timeoutHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,84 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>A unique identifier for a container in a compute on a managed container fleet
|
||||
* instance. This information makes it possible to remotely connect to a specific
|
||||
* container on a fleet instance.</p> <p> <b>Related to:</b>
|
||||
* <a>ContainerAttribute</a> </p> <p> <b>Use with: </b> <a>GetComputeAccess</a>
|
||||
* </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerIdentifier">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerIdentifier
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerIdentifier();
|
||||
AWS_GAMELIFT_API ContainerIdentifier(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerIdentifier& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The identifier for a container that's running in a compute. </p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerName() const{ return m_containerName; }
|
||||
inline bool ContainerNameHasBeenSet() const { return m_containerNameHasBeenSet; }
|
||||
inline void SetContainerName(const Aws::String& value) { m_containerNameHasBeenSet = true; m_containerName = value; }
|
||||
inline void SetContainerName(Aws::String&& value) { m_containerNameHasBeenSet = true; m_containerName = std::move(value); }
|
||||
inline void SetContainerName(const char* value) { m_containerNameHasBeenSet = true; m_containerName.assign(value); }
|
||||
inline ContainerIdentifier& WithContainerName(const Aws::String& value) { SetContainerName(value); return *this;}
|
||||
inline ContainerIdentifier& WithContainerName(Aws::String&& value) { SetContainerName(std::move(value)); return *this;}
|
||||
inline ContainerIdentifier& WithContainerName(const char* value) { SetContainerName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The runtime ID for the container that's running in a compute. This value is
|
||||
* unique within the compute. It is returned as a <code>ContainerAttribute</code>
|
||||
* value in a <code>Compute</code> object.</p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerRuntimeId() const{ return m_containerRuntimeId; }
|
||||
inline bool ContainerRuntimeIdHasBeenSet() const { return m_containerRuntimeIdHasBeenSet; }
|
||||
inline void SetContainerRuntimeId(const Aws::String& value) { m_containerRuntimeIdHasBeenSet = true; m_containerRuntimeId = value; }
|
||||
inline void SetContainerRuntimeId(Aws::String&& value) { m_containerRuntimeIdHasBeenSet = true; m_containerRuntimeId = std::move(value); }
|
||||
inline void SetContainerRuntimeId(const char* value) { m_containerRuntimeIdHasBeenSet = true; m_containerRuntimeId.assign(value); }
|
||||
inline ContainerIdentifier& WithContainerRuntimeId(const Aws::String& value) { SetContainerRuntimeId(value); return *this;}
|
||||
inline ContainerIdentifier& WithContainerRuntimeId(Aws::String&& value) { SetContainerRuntimeId(std::move(value)); return *this;}
|
||||
inline ContainerIdentifier& WithContainerRuntimeId(const char* value) { SetContainerRuntimeId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_containerName;
|
||||
bool m_containerNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_containerRuntimeId;
|
||||
bool m_containerRuntimeIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ContainerMountPointAccessLevel.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>A mount point that binds a container to a file or directory on the host
|
||||
* system. </p> <p> <b>Part of:</b> <a>GameServerContainerDefinition</a>,
|
||||
* <a>GameServerContainerDefinitionInput</a>, <a>SupportContainerDefinition</a>,
|
||||
* <a>SupportContainerDefinitionInput</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerMountPoint">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerMountPoint
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerMountPoint();
|
||||
AWS_GAMELIFT_API ContainerMountPoint(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerMountPoint& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The path to the source file or directory. </p>
|
||||
*/
|
||||
inline const Aws::String& GetInstancePath() const{ return m_instancePath; }
|
||||
inline bool InstancePathHasBeenSet() const { return m_instancePathHasBeenSet; }
|
||||
inline void SetInstancePath(const Aws::String& value) { m_instancePathHasBeenSet = true; m_instancePath = value; }
|
||||
inline void SetInstancePath(Aws::String&& value) { m_instancePathHasBeenSet = true; m_instancePath = std::move(value); }
|
||||
inline void SetInstancePath(const char* value) { m_instancePathHasBeenSet = true; m_instancePath.assign(value); }
|
||||
inline ContainerMountPoint& WithInstancePath(const Aws::String& value) { SetInstancePath(value); return *this;}
|
||||
inline ContainerMountPoint& WithInstancePath(Aws::String&& value) { SetInstancePath(std::move(value)); return *this;}
|
||||
inline ContainerMountPoint& WithInstancePath(const char* value) { SetInstancePath(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The mount path on the container. If this property isn't set, the instance
|
||||
* path is used.</p>
|
||||
*/
|
||||
inline const Aws::String& GetContainerPath() const{ return m_containerPath; }
|
||||
inline bool ContainerPathHasBeenSet() const { return m_containerPathHasBeenSet; }
|
||||
inline void SetContainerPath(const Aws::String& value) { m_containerPathHasBeenSet = true; m_containerPath = value; }
|
||||
inline void SetContainerPath(Aws::String&& value) { m_containerPathHasBeenSet = true; m_containerPath = std::move(value); }
|
||||
inline void SetContainerPath(const char* value) { m_containerPathHasBeenSet = true; m_containerPath.assign(value); }
|
||||
inline ContainerMountPoint& WithContainerPath(const Aws::String& value) { SetContainerPath(value); return *this;}
|
||||
inline ContainerMountPoint& WithContainerPath(Aws::String&& value) { SetContainerPath(std::move(value)); return *this;}
|
||||
inline ContainerMountPoint& WithContainerPath(const char* value) { SetContainerPath(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of access for the container.</p>
|
||||
*/
|
||||
inline const ContainerMountPointAccessLevel& GetAccessLevel() const{ return m_accessLevel; }
|
||||
inline bool AccessLevelHasBeenSet() const { return m_accessLevelHasBeenSet; }
|
||||
inline void SetAccessLevel(const ContainerMountPointAccessLevel& value) { m_accessLevelHasBeenSet = true; m_accessLevel = value; }
|
||||
inline void SetAccessLevel(ContainerMountPointAccessLevel&& value) { m_accessLevelHasBeenSet = true; m_accessLevel = std::move(value); }
|
||||
inline ContainerMountPoint& WithAccessLevel(const ContainerMountPointAccessLevel& value) { SetAccessLevel(value); return *this;}
|
||||
inline ContainerMountPoint& WithAccessLevel(ContainerMountPointAccessLevel&& value) { SetAccessLevel(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_instancePath;
|
||||
bool m_instancePathHasBeenSet = false;
|
||||
|
||||
Aws::String m_containerPath;
|
||||
bool m_containerPathHasBeenSet = false;
|
||||
|
||||
ContainerMountPointAccessLevel m_accessLevel;
|
||||
bool m_accessLevelHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerMountPointAccessLevel
|
||||
{
|
||||
NOT_SET,
|
||||
READ_ONLY,
|
||||
READ_AND_WRITE
|
||||
};
|
||||
|
||||
namespace ContainerMountPointAccessLevelMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerMountPointAccessLevel GetContainerMountPointAccessLevelForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerMountPointAccessLevel(ContainerMountPointAccessLevel value);
|
||||
} // namespace ContainerMountPointAccessLevelMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
enum class ContainerOperatingSystem
|
||||
{
|
||||
NOT_SET,
|
||||
AMAZON_LINUX_2023
|
||||
};
|
||||
|
||||
namespace ContainerOperatingSystemMapper
|
||||
{
|
||||
AWS_GAMELIFT_API ContainerOperatingSystem GetContainerOperatingSystemForName(const Aws::String& name);
|
||||
|
||||
AWS_GAMELIFT_API Aws::String GetNameForContainerOperatingSystem(ContainerOperatingSystem value);
|
||||
} // namespace ContainerOperatingSystemMapper
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/ContainerPortRange.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>A set of port ranges that can be opened on the container. A process that's
|
||||
* running in the container can bind to a port number, making it accessible to
|
||||
* inbound traffic. Container ports map to a container fleet's connection ports.
|
||||
* </p> <p> <b>Part of:</b> <a>GameServerContainerDefinition</a>,
|
||||
* <a>GameServerContainerDefinitionInput</a>, <a>SupportContainerDefinition</a>,
|
||||
* <a>SupportContainerDefinitionInput</a> </p><p><h3>See Also:</h3> <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerPortConfiguration">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerPortConfiguration
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerPortConfiguration();
|
||||
AWS_GAMELIFT_API ContainerPortConfiguration(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerPortConfiguration& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of one or more container port number ranges. The ranges can't overlap.
|
||||
* </p>
|
||||
*/
|
||||
inline const Aws::Vector<ContainerPortRange>& GetContainerPortRanges() const{ return m_containerPortRanges; }
|
||||
inline bool ContainerPortRangesHasBeenSet() const { return m_containerPortRangesHasBeenSet; }
|
||||
inline void SetContainerPortRanges(const Aws::Vector<ContainerPortRange>& value) { m_containerPortRangesHasBeenSet = true; m_containerPortRanges = value; }
|
||||
inline void SetContainerPortRanges(Aws::Vector<ContainerPortRange>&& value) { m_containerPortRangesHasBeenSet = true; m_containerPortRanges = std::move(value); }
|
||||
inline ContainerPortConfiguration& WithContainerPortRanges(const Aws::Vector<ContainerPortRange>& value) { SetContainerPortRanges(value); return *this;}
|
||||
inline ContainerPortConfiguration& WithContainerPortRanges(Aws::Vector<ContainerPortRange>&& value) { SetContainerPortRanges(std::move(value)); return *this;}
|
||||
inline ContainerPortConfiguration& AddContainerPortRanges(const ContainerPortRange& value) { m_containerPortRangesHasBeenSet = true; m_containerPortRanges.push_back(value); return *this; }
|
||||
inline ContainerPortConfiguration& AddContainerPortRanges(ContainerPortRange&& value) { m_containerPortRangesHasBeenSet = true; m_containerPortRanges.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<ContainerPortRange> m_containerPortRanges;
|
||||
bool m_containerPortRangesHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/IpProtocol.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
class JsonView;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
* <p>A set of one or more port numbers that can be opened on the container. </p>
|
||||
* <p> <b>Part of:</b> <a>ContainerPortConfiguration</a> </p><p><h3>See Also:</h3>
|
||||
* <a
|
||||
* href="http://docs.aws.amazon.com/goto/WebAPI/gamelift-2015-10-01/ContainerPortRange">AWS
|
||||
* API Reference</a></p>
|
||||
*/
|
||||
class ContainerPortRange
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API ContainerPortRange();
|
||||
AWS_GAMELIFT_API ContainerPortRange(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API ContainerPortRange& operator=(Aws::Utils::Json::JsonView jsonValue);
|
||||
AWS_GAMELIFT_API Aws::Utils::Json::JsonValue Jsonize() const;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A starting value for the range of allowed port numbers.</p>
|
||||
*/
|
||||
inline int GetFromPort() const{ return m_fromPort; }
|
||||
inline bool FromPortHasBeenSet() const { return m_fromPortHasBeenSet; }
|
||||
inline void SetFromPort(int value) { m_fromPortHasBeenSet = true; m_fromPort = value; }
|
||||
inline ContainerPortRange& WithFromPort(int value) { SetFromPort(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An ending value for the range of allowed port numbers. Port numbers are
|
||||
* end-inclusive. This value must be equal to or greater than
|
||||
* <code>FromPort</code>.</p>
|
||||
*/
|
||||
inline int GetToPort() const{ return m_toPort; }
|
||||
inline bool ToPortHasBeenSet() const { return m_toPortHasBeenSet; }
|
||||
inline void SetToPort(int value) { m_toPortHasBeenSet = true; m_toPort = value; }
|
||||
inline ContainerPortRange& WithToPort(int value) { SetToPort(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The network protocol that these ports support. </p>
|
||||
*/
|
||||
inline const IpProtocol& GetProtocol() const{ return m_protocol; }
|
||||
inline bool ProtocolHasBeenSet() const { return m_protocolHasBeenSet; }
|
||||
inline void SetProtocol(const IpProtocol& value) { m_protocolHasBeenSet = true; m_protocol = value; }
|
||||
inline void SetProtocol(IpProtocol&& value) { m_protocolHasBeenSet = true; m_protocol = std::move(value); }
|
||||
inline ContainerPortRange& WithProtocol(const IpProtocol& value) { SetProtocol(value); return *this;}
|
||||
inline ContainerPortRange& WithProtocol(IpProtocol&& value) { SetProtocol(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
int m_fromPort;
|
||||
bool m_fromPortHasBeenSet = false;
|
||||
|
||||
int m_toPort;
|
||||
bool m_toPortHasBeenSet = false;
|
||||
|
||||
IpProtocol m_protocol;
|
||||
bool m_protocolHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/RoutingStrategy.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateAliasRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateAliasRequest();
|
||||
|
||||
// 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 "CreateAlias"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with an alias. Alias names do not need
|
||||
* to be unique.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateAliasRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateAliasRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateAliasRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A human-readable description of the alias.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateAliasRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateAliasRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateAliasRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The routing configuration, including routing type and fleet target, for the
|
||||
* alias. </p>
|
||||
*/
|
||||
inline const RoutingStrategy& GetRoutingStrategy() const{ return m_routingStrategy; }
|
||||
inline bool RoutingStrategyHasBeenSet() const { return m_routingStrategyHasBeenSet; }
|
||||
inline void SetRoutingStrategy(const RoutingStrategy& value) { m_routingStrategyHasBeenSet = true; m_routingStrategy = value; }
|
||||
inline void SetRoutingStrategy(RoutingStrategy&& value) { m_routingStrategyHasBeenSet = true; m_routingStrategy = std::move(value); }
|
||||
inline CreateAliasRequest& WithRoutingStrategy(const RoutingStrategy& value) { SetRoutingStrategy(value); return *this;}
|
||||
inline CreateAliasRequest& WithRoutingStrategy(RoutingStrategy&& value) { SetRoutingStrategy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new alias resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateAliasRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateAliasRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateAliasRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateAliasRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
RoutingStrategy m_routingStrategy;
|
||||
bool m_routingStrategyHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/Alias.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateAliasResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateAliasResult();
|
||||
AWS_GAMELIFT_API CreateAliasResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateAliasResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created alias resource.</p>
|
||||
*/
|
||||
inline const Alias& GetAlias() const{ return m_alias; }
|
||||
inline void SetAlias(const Alias& value) { m_alias = value; }
|
||||
inline void SetAlias(Alias&& value) { m_alias = std::move(value); }
|
||||
inline CreateAliasResult& WithAlias(const Alias& value) { SetAlias(value); return *this;}
|
||||
inline CreateAliasResult& WithAlias(Alias&& value) { SetAlias(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateAliasResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateAliasResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateAliasResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Alias m_alias;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/S3Location.h>
|
||||
#include <aws/gamelift/model/OperatingSystem.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateBuildRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateBuildRequest();
|
||||
|
||||
// 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 "CreateBuild"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with a build. Build names do not need
|
||||
* to be unique. You can change this value later. </p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateBuildRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateBuildRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateBuildRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Version information that is associated with a build or script. Version
|
||||
* strings do not need to be unique. You can change this value later. </p>
|
||||
*/
|
||||
inline const Aws::String& GetVersion() const{ return m_version; }
|
||||
inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
|
||||
inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
|
||||
inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
|
||||
inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
|
||||
inline CreateBuildRequest& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
|
||||
inline CreateBuildRequest& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
|
||||
inline CreateBuildRequest& WithVersion(const char* value) { SetVersion(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Information indicating where your game build files are stored. Use this
|
||||
* parameter only when creating a build with files stored in an Amazon S3 bucket
|
||||
* that you own. The storage location must specify an Amazon S3 bucket name and
|
||||
* key. The location must also specify a role ARN that you set up to allow Amazon
|
||||
* GameLift to access your Amazon S3 bucket. The S3 bucket and your new build must
|
||||
* be in the same Region.</p> <p>If a <code>StorageLocation</code> is specified,
|
||||
* the size of your file can be found in your Amazon S3 bucket. Amazon GameLift
|
||||
* will report a <code>SizeOnDisk</code> of 0. </p>
|
||||
*/
|
||||
inline const S3Location& GetStorageLocation() const{ return m_storageLocation; }
|
||||
inline bool StorageLocationHasBeenSet() const { return m_storageLocationHasBeenSet; }
|
||||
inline void SetStorageLocation(const S3Location& value) { m_storageLocationHasBeenSet = true; m_storageLocation = value; }
|
||||
inline void SetStorageLocation(S3Location&& value) { m_storageLocationHasBeenSet = true; m_storageLocation = std::move(value); }
|
||||
inline CreateBuildRequest& WithStorageLocation(const S3Location& value) { SetStorageLocation(value); return *this;}
|
||||
inline CreateBuildRequest& WithStorageLocation(S3Location&& value) { SetStorageLocation(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The environment that your game server binaries run on. This value determines
|
||||
* the type of fleet resources that you use for this build. If your game build
|
||||
* contains multiple executables, they all must run on the same operating system.
|
||||
* This parameter is required, and there's no default value. You can't change a
|
||||
* build's operating system later.</p> <p>Amazon Linux 2 (AL2) will reach
|
||||
* end of support on 6/30/2025. See more details in the <a
|
||||
* href="https://aws.amazon.com/amazon-linux-2/faqs/">Amazon Linux 2 FAQs</a>. For
|
||||
* game servers that are hosted on AL2 and use Amazon GameLift server SDK 4.x.,
|
||||
* first update the game server build to server SDK 5.x, and then deploy to AL2023
|
||||
* instances. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html">
|
||||
* Migrate to Amazon GameLift server SDK version 5.</a> </p>
|
||||
*/
|
||||
inline const OperatingSystem& GetOperatingSystem() const{ return m_operatingSystem; }
|
||||
inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
|
||||
inline void SetOperatingSystem(const OperatingSystem& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = value; }
|
||||
inline void SetOperatingSystem(OperatingSystem&& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = std::move(value); }
|
||||
inline CreateBuildRequest& WithOperatingSystem(const OperatingSystem& value) { SetOperatingSystem(value); return *this;}
|
||||
inline CreateBuildRequest& WithOperatingSystem(OperatingSystem&& value) { SetOperatingSystem(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new build resource. Tags are developer
|
||||
* defined key-value pairs. Tagging Amazon Web Services resources are useful for
|
||||
* resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>. Once the resource is created, you can use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_TagResource.html">TagResource</a>,
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_UntagResource.html">UntagResource</a>,
|
||||
* and <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_ListTagsForResource.html">ListTagsForResource</a>
|
||||
* to add, remove, and view tags. The maximum tag limit may be lower than stated.
|
||||
* See the Amazon Web Services General Reference for actual tagging limits.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateBuildRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateBuildRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateBuildRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateBuildRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A server SDK version you used when integrating your game server build with
|
||||
* Amazon GameLift. For more information see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-custom-intro.html">Integrate
|
||||
* games with custom game servers</a>. By default Amazon GameLift sets this value
|
||||
* to <code>4.0.2</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetServerSdkVersion() const{ return m_serverSdkVersion; }
|
||||
inline bool ServerSdkVersionHasBeenSet() const { return m_serverSdkVersionHasBeenSet; }
|
||||
inline void SetServerSdkVersion(const Aws::String& value) { m_serverSdkVersionHasBeenSet = true; m_serverSdkVersion = value; }
|
||||
inline void SetServerSdkVersion(Aws::String&& value) { m_serverSdkVersionHasBeenSet = true; m_serverSdkVersion = std::move(value); }
|
||||
inline void SetServerSdkVersion(const char* value) { m_serverSdkVersionHasBeenSet = true; m_serverSdkVersion.assign(value); }
|
||||
inline CreateBuildRequest& WithServerSdkVersion(const Aws::String& value) { SetServerSdkVersion(value); return *this;}
|
||||
inline CreateBuildRequest& WithServerSdkVersion(Aws::String&& value) { SetServerSdkVersion(std::move(value)); return *this;}
|
||||
inline CreateBuildRequest& WithServerSdkVersion(const char* value) { SetServerSdkVersion(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_version;
|
||||
bool m_versionHasBeenSet = false;
|
||||
|
||||
S3Location m_storageLocation;
|
||||
bool m_storageLocationHasBeenSet = false;
|
||||
|
||||
OperatingSystem m_operatingSystem;
|
||||
bool m_operatingSystemHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
|
||||
Aws::String m_serverSdkVersion;
|
||||
bool m_serverSdkVersionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/Build.h>
|
||||
#include <aws/gamelift/model/AwsCredentials.h>
|
||||
#include <aws/gamelift/model/S3Location.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateBuildResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateBuildResult();
|
||||
AWS_GAMELIFT_API CreateBuildResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateBuildResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created build resource, including a unique build IDs and status.
|
||||
* </p>
|
||||
*/
|
||||
inline const Build& GetBuild() const{ return m_build; }
|
||||
inline void SetBuild(const Build& value) { m_build = value; }
|
||||
inline void SetBuild(Build&& value) { m_build = std::move(value); }
|
||||
inline CreateBuildResult& WithBuild(const Build& value) { SetBuild(value); return *this;}
|
||||
inline CreateBuildResult& WithBuild(Build&& value) { SetBuild(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>This element is returned only when the operation is called without a storage
|
||||
* location. It contains credentials to use when you are uploading a build file to
|
||||
* an Amazon S3 bucket that is owned by Amazon GameLift. Credentials have a limited
|
||||
* life span. To refresh these credentials, call <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_RequestUploadCredentials.html">RequestUploadCredentials</a>.
|
||||
* </p>
|
||||
*/
|
||||
inline const AwsCredentials& GetUploadCredentials() const{ return m_uploadCredentials; }
|
||||
inline void SetUploadCredentials(const AwsCredentials& value) { m_uploadCredentials = value; }
|
||||
inline void SetUploadCredentials(AwsCredentials&& value) { m_uploadCredentials = std::move(value); }
|
||||
inline CreateBuildResult& WithUploadCredentials(const AwsCredentials& value) { SetUploadCredentials(value); return *this;}
|
||||
inline CreateBuildResult& WithUploadCredentials(AwsCredentials&& value) { SetUploadCredentials(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Amazon S3 location for your game build file, including bucket name and
|
||||
* key.</p>
|
||||
*/
|
||||
inline const S3Location& GetStorageLocation() const{ return m_storageLocation; }
|
||||
inline void SetStorageLocation(const S3Location& value) { m_storageLocation = value; }
|
||||
inline void SetStorageLocation(S3Location&& value) { m_storageLocation = std::move(value); }
|
||||
inline CreateBuildResult& WithStorageLocation(const S3Location& value) { SetStorageLocation(value); return *this;}
|
||||
inline CreateBuildResult& WithStorageLocation(S3Location&& value) { SetStorageLocation(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateBuildResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateBuildResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateBuildResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Build m_build;
|
||||
|
||||
AwsCredentials m_uploadCredentials;
|
||||
|
||||
S3Location m_storageLocation;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,402 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ConnectionPortRange.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/ContainerFleetBillingType.h>
|
||||
#include <aws/gamelift/model/ProtectionPolicy.h>
|
||||
#include <aws/gamelift/model/GameSessionCreationLimitPolicy.h>
|
||||
#include <aws/gamelift/model/LogConfiguration.h>
|
||||
#include <aws/gamelift/model/IpPermission.h>
|
||||
#include <aws/gamelift/model/LocationConfiguration.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateContainerFleetRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateContainerFleetRequest();
|
||||
|
||||
// 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 "CreateContainerFleet"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for an Identity and Access Management (IAM) role with
|
||||
* permissions to run your containers on resources that are managed by Amazon
|
||||
* GameLift. Use an IAM service role with the
|
||||
* <code>GameLiftContainerFleetPolicy</code> managed policy attached. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/setting-up-role.html">Set
|
||||
* up an IAM service role</a>. You can't change this fleet property after the fleet
|
||||
* is created.</p> <p>IAM role ARN values use the following pattern:
|
||||
* <code>arn:aws:iam::[Amazon Web Services account]:role/[role name]</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetRoleArn() const{ return m_fleetRoleArn; }
|
||||
inline bool FleetRoleArnHasBeenSet() const { return m_fleetRoleArnHasBeenSet; }
|
||||
inline void SetFleetRoleArn(const Aws::String& value) { m_fleetRoleArnHasBeenSet = true; m_fleetRoleArn = value; }
|
||||
inline void SetFleetRoleArn(Aws::String&& value) { m_fleetRoleArnHasBeenSet = true; m_fleetRoleArn = std::move(value); }
|
||||
inline void SetFleetRoleArn(const char* value) { m_fleetRoleArnHasBeenSet = true; m_fleetRoleArn.assign(value); }
|
||||
inline CreateContainerFleetRequest& WithFleetRoleArn(const Aws::String& value) { SetFleetRoleArn(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithFleetRoleArn(Aws::String&& value) { SetFleetRoleArn(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& WithFleetRoleArn(const char* value) { SetFleetRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A meaningful description of the container fleet.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateContainerFleetRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A container group definition resource that describes how to deploy containers
|
||||
* with your game server build and support software onto each fleet instance. You
|
||||
* can specify the container group definition's name to use the latest version.
|
||||
* Alternatively, provide an ARN value with a specific version number.</p>
|
||||
* <p>Create a container group definition by calling
|
||||
* <a>CreateContainerGroupDefinition</a>. This operation creates a
|
||||
* <a>ContainerGroupDefinition</a> resource. </p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerContainerGroupDefinitionName() const{ return m_gameServerContainerGroupDefinitionName; }
|
||||
inline bool GameServerContainerGroupDefinitionNameHasBeenSet() const { return m_gameServerContainerGroupDefinitionNameHasBeenSet; }
|
||||
inline void SetGameServerContainerGroupDefinitionName(const Aws::String& value) { m_gameServerContainerGroupDefinitionNameHasBeenSet = true; m_gameServerContainerGroupDefinitionName = value; }
|
||||
inline void SetGameServerContainerGroupDefinitionName(Aws::String&& value) { m_gameServerContainerGroupDefinitionNameHasBeenSet = true; m_gameServerContainerGroupDefinitionName = std::move(value); }
|
||||
inline void SetGameServerContainerGroupDefinitionName(const char* value) { m_gameServerContainerGroupDefinitionNameHasBeenSet = true; m_gameServerContainerGroupDefinitionName.assign(value); }
|
||||
inline CreateContainerFleetRequest& WithGameServerContainerGroupDefinitionName(const Aws::String& value) { SetGameServerContainerGroupDefinitionName(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithGameServerContainerGroupDefinitionName(Aws::String&& value) { SetGameServerContainerGroupDefinitionName(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& WithGameServerContainerGroupDefinitionName(const char* value) { SetGameServerContainerGroupDefinitionName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of a container group definition resource that describes a set of
|
||||
* axillary software. A fleet instance has one process for executables in this
|
||||
* container group. A per-instance container group is optional. You can update the
|
||||
* fleet to add or remove a per-instance container group at any time. You can
|
||||
* specify the container group definition's name to use the latest version.
|
||||
* Alternatively, provide an ARN value with a specific version number. </p>
|
||||
* <p>Create a container group definition by calling
|
||||
* <a>CreateContainerGroupDefinition</a>. This operation creates a
|
||||
* <a>ContainerGroupDefinition</a> resource.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPerInstanceContainerGroupDefinitionName() const{ return m_perInstanceContainerGroupDefinitionName; }
|
||||
inline bool PerInstanceContainerGroupDefinitionNameHasBeenSet() const { return m_perInstanceContainerGroupDefinitionNameHasBeenSet; }
|
||||
inline void SetPerInstanceContainerGroupDefinitionName(const Aws::String& value) { m_perInstanceContainerGroupDefinitionNameHasBeenSet = true; m_perInstanceContainerGroupDefinitionName = value; }
|
||||
inline void SetPerInstanceContainerGroupDefinitionName(Aws::String&& value) { m_perInstanceContainerGroupDefinitionNameHasBeenSet = true; m_perInstanceContainerGroupDefinitionName = std::move(value); }
|
||||
inline void SetPerInstanceContainerGroupDefinitionName(const char* value) { m_perInstanceContainerGroupDefinitionNameHasBeenSet = true; m_perInstanceContainerGroupDefinitionName.assign(value); }
|
||||
inline CreateContainerFleetRequest& WithPerInstanceContainerGroupDefinitionName(const Aws::String& value) { SetPerInstanceContainerGroupDefinitionName(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithPerInstanceContainerGroupDefinitionName(Aws::String&& value) { SetPerInstanceContainerGroupDefinitionName(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& WithPerInstanceContainerGroupDefinitionName(const char* value) { SetPerInstanceContainerGroupDefinitionName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The set of port numbers to open on each fleet instance. A fleet's connection
|
||||
* ports map to container ports that are configured in the fleet's container group
|
||||
* definitions. </p> <p>By default, Amazon GameLift calculates an optimal port
|
||||
* range based on your fleet configuration. To use the calculated range, don't set
|
||||
* this parameter. The values are:</p> <ul> <li> <p>Port range: 4192 to a number
|
||||
* calculated based on your fleet configuration. Amazon GameLift uses the following
|
||||
* formula: <code>4192 + [# of game server container groups per fleet instance] *
|
||||
* [# of container ports in the game server container group definition] + [# of
|
||||
* container ports in the game server container group definition]</code> </p> </li>
|
||||
* </ul> <p>You can also choose to manually set this parameter. When manually
|
||||
* setting this parameter, you must use port numbers that match the fleet's inbound
|
||||
* permissions port range.</p> <p>If you set values manually, Amazon
|
||||
* GameLift no longer calculates a port range for you, even if you later remove the
|
||||
* manual settings. </p>
|
||||
*/
|
||||
inline const ConnectionPortRange& GetInstanceConnectionPortRange() const{ return m_instanceConnectionPortRange; }
|
||||
inline bool InstanceConnectionPortRangeHasBeenSet() const { return m_instanceConnectionPortRangeHasBeenSet; }
|
||||
inline void SetInstanceConnectionPortRange(const ConnectionPortRange& value) { m_instanceConnectionPortRangeHasBeenSet = true; m_instanceConnectionPortRange = value; }
|
||||
inline void SetInstanceConnectionPortRange(ConnectionPortRange&& value) { m_instanceConnectionPortRangeHasBeenSet = true; m_instanceConnectionPortRange = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithInstanceConnectionPortRange(const ConnectionPortRange& value) { SetInstanceConnectionPortRange(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithInstanceConnectionPortRange(ConnectionPortRange&& value) { SetInstanceConnectionPortRange(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The IP address ranges and port settings that allow inbound traffic to access
|
||||
* game server processes and other processes on this fleet. As a best practice,
|
||||
* when remotely accessing a fleet instance, we recommend opening ports only when
|
||||
* you need them and closing them when you're finished.</p> <p>By default, Amazon
|
||||
* GameLift calculates an optimal port range based on your fleet configuration. To
|
||||
* use the calculated range, don't set this parameter. The values are:</p> <ul>
|
||||
* <li> <p>Protocol: UDP</p> </li> <li> <p>Port range: 4192 to a number calculated
|
||||
* based on your fleet configuration. Amazon GameLift uses the following formula:
|
||||
* <code>4192 + [# of game server container groups per fleet instance] * [# of
|
||||
* container ports in the game server container group definition] + [# of container
|
||||
* ports in the game server container group definition]</code> </p> </li> </ul>
|
||||
* <p>You can also choose to manually set this parameter. When manually setting
|
||||
* this parameter, you must use port numbers that match the fleet's connection port
|
||||
* range.</p> <p>If you set values manually, Amazon GameLift no longer
|
||||
* calculates a port range for you, even if you later remove the manual settings.
|
||||
* </p>
|
||||
*/
|
||||
inline const Aws::Vector<IpPermission>& GetInstanceInboundPermissions() const{ return m_instanceInboundPermissions; }
|
||||
inline bool InstanceInboundPermissionsHasBeenSet() const { return m_instanceInboundPermissionsHasBeenSet; }
|
||||
inline void SetInstanceInboundPermissions(const Aws::Vector<IpPermission>& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions = value; }
|
||||
inline void SetInstanceInboundPermissions(Aws::Vector<IpPermission>&& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithInstanceInboundPermissions(const Aws::Vector<IpPermission>& value) { SetInstanceInboundPermissions(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithInstanceInboundPermissions(Aws::Vector<IpPermission>&& value) { SetInstanceInboundPermissions(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& AddInstanceInboundPermissions(const IpPermission& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions.push_back(value); return *this; }
|
||||
inline CreateContainerFleetRequest& AddInstanceInboundPermissions(IpPermission&& value) { m_instanceInboundPermissionsHasBeenSet = true; m_instanceInboundPermissions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of times to replicate the game server container group on each
|
||||
* fleet instance. </p> <p>By default, Amazon GameLift calculates the maximum
|
||||
* number of game server container groups that can fit on each instance. This
|
||||
* calculation is based on the CPU and memory resources of the fleet's instance
|
||||
* type). To use the calculated maximum, don't set this parameter. If you set this
|
||||
* number manually, Amazon GameLift uses your value as long as it's less than the
|
||||
* calculated maximum.</p>
|
||||
*/
|
||||
inline int GetGameServerContainerGroupsPerInstance() const{ return m_gameServerContainerGroupsPerInstance; }
|
||||
inline bool GameServerContainerGroupsPerInstanceHasBeenSet() const { return m_gameServerContainerGroupsPerInstanceHasBeenSet; }
|
||||
inline void SetGameServerContainerGroupsPerInstance(int value) { m_gameServerContainerGroupsPerInstanceHasBeenSet = true; m_gameServerContainerGroupsPerInstance = value; }
|
||||
inline CreateContainerFleetRequest& WithGameServerContainerGroupsPerInstance(int value) { SetGameServerContainerGroupsPerInstance(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon EC2 instance type to use for all instances in the fleet. For
|
||||
* multi-location fleets, the instance type must be available in the home region
|
||||
* and all remote locations. Instance type determines the computing resources and
|
||||
* processing power that's available to host your game servers. This includes
|
||||
* including CPU, memory, storage, and networking capacity. </p> <p>By default,
|
||||
* Amazon GameLift selects an instance type that fits the needs of your container
|
||||
* groups and is available in all selected fleet locations. You can also choose to
|
||||
* manually set this parameter. See <a
|
||||
* href="http://aws.amazon.com/ec2/instance-types/">Amazon Elastic Compute Cloud
|
||||
* Instance Types</a> for detailed descriptions of Amazon EC2 instance types.</p>
|
||||
* <p>You can't update this fleet property later.</p>
|
||||
*/
|
||||
inline const Aws::String& GetInstanceType() const{ return m_instanceType; }
|
||||
inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
|
||||
inline void SetInstanceType(const Aws::String& value) { m_instanceTypeHasBeenSet = true; m_instanceType = value; }
|
||||
inline void SetInstanceType(Aws::String&& value) { m_instanceTypeHasBeenSet = true; m_instanceType = std::move(value); }
|
||||
inline void SetInstanceType(const char* value) { m_instanceTypeHasBeenSet = true; m_instanceType.assign(value); }
|
||||
inline CreateContainerFleetRequest& WithInstanceType(const Aws::String& value) { SetInstanceType(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithInstanceType(Aws::String&& value) { SetInstanceType(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& WithInstanceType(const char* value) { SetInstanceType(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates whether to use On-Demand or Spot instances for this fleet. Learn
|
||||
* more about when to use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot">
|
||||
* On-Demand versus Spot Instances</a>. This fleet property can't be changed after
|
||||
* the fleet is created.</p> <p>By default, this property is set to
|
||||
* <code>ON_DEMAND</code>.</p> <p>You can't update this fleet property later.</p>
|
||||
*/
|
||||
inline const ContainerFleetBillingType& GetBillingType() const{ return m_billingType; }
|
||||
inline bool BillingTypeHasBeenSet() const { return m_billingTypeHasBeenSet; }
|
||||
inline void SetBillingType(const ContainerFleetBillingType& value) { m_billingTypeHasBeenSet = true; m_billingType = value; }
|
||||
inline void SetBillingType(ContainerFleetBillingType&& value) { m_billingTypeHasBeenSet = true; m_billingType = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithBillingType(const ContainerFleetBillingType& value) { SetBillingType(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithBillingType(ContainerFleetBillingType&& value) { SetBillingType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of locations to deploy container fleet instances to. You can add any
|
||||
* Amazon Web Services Region or Local Zone that's supported by Amazon GameLift.
|
||||
* Provide a list of one or more Amazon Web Services Region codes, such as
|
||||
* <code>us-west-2</code>, or Local Zone names. Also include the fleet's home
|
||||
* Region, which is the Amazon Web Services Region where the fleet is created. For
|
||||
* a list of supported Regions and Local Zones, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-regions.html">
|
||||
* Amazon GameLift service locations</a> for managed hosting.</p>
|
||||
*/
|
||||
inline const Aws::Vector<LocationConfiguration>& GetLocations() const{ return m_locations; }
|
||||
inline bool LocationsHasBeenSet() const { return m_locationsHasBeenSet; }
|
||||
inline void SetLocations(const Aws::Vector<LocationConfiguration>& value) { m_locationsHasBeenSet = true; m_locations = value; }
|
||||
inline void SetLocations(Aws::Vector<LocationConfiguration>&& value) { m_locationsHasBeenSet = true; m_locations = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithLocations(const Aws::Vector<LocationConfiguration>& value) { SetLocations(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithLocations(Aws::Vector<LocationConfiguration>&& value) { SetLocations(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& AddLocations(const LocationConfiguration& value) { m_locationsHasBeenSet = true; m_locations.push_back(value); return *this; }
|
||||
inline CreateContainerFleetRequest& AddLocations(LocationConfiguration&& value) { m_locationsHasBeenSet = true; m_locations.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of an Amazon Web Services CloudWatch metric group to add this fleet
|
||||
* to. You can use a metric group to aggregate metrics for multiple fleets. You can
|
||||
* specify an existing metric group name or use a new name to create a new metric
|
||||
* group. Each fleet can have only one metric group, but you can change this value
|
||||
* at any time. </p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetMetricGroups() const{ return m_metricGroups; }
|
||||
inline bool MetricGroupsHasBeenSet() const { return m_metricGroupsHasBeenSet; }
|
||||
inline void SetMetricGroups(const Aws::Vector<Aws::String>& value) { m_metricGroupsHasBeenSet = true; m_metricGroups = value; }
|
||||
inline void SetMetricGroups(Aws::Vector<Aws::String>&& value) { m_metricGroupsHasBeenSet = true; m_metricGroups = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithMetricGroups(const Aws::Vector<Aws::String>& value) { SetMetricGroups(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithMetricGroups(Aws::Vector<Aws::String>&& value) { SetMetricGroups(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& AddMetricGroups(const Aws::String& value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(value); return *this; }
|
||||
inline CreateContainerFleetRequest& AddMetricGroups(Aws::String&& value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(std::move(value)); return *this; }
|
||||
inline CreateContainerFleetRequest& AddMetricGroups(const char* value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Determines whether Amazon GameLift can shut down game sessions on the fleet
|
||||
* that are actively running and hosting players. Amazon GameLift might prompt an
|
||||
* instance shutdown when scaling down fleet capacity or when retiring unhealthy
|
||||
* instances. You can also set game session protection for individual game sessions
|
||||
* using <a
|
||||
* href="gamelift/latest/apireference/API_UpdateGameSession.html">UpdateGameSession</a>.</p>
|
||||
* <ul> <li> <p> <b>NoProtection</b> -- Game sessions can be shut down during
|
||||
* active gameplay. </p> </li> <li> <p> <b>FullProtection</b> -- Game sessions in
|
||||
* <code>ACTIVE</code> status can't be shut down.</p> </li> </ul> <p>By default,
|
||||
* this property is set to <code>NoProtection</code>. </p>
|
||||
*/
|
||||
inline const ProtectionPolicy& GetNewGameSessionProtectionPolicy() const{ return m_newGameSessionProtectionPolicy; }
|
||||
inline bool NewGameSessionProtectionPolicyHasBeenSet() const { return m_newGameSessionProtectionPolicyHasBeenSet; }
|
||||
inline void SetNewGameSessionProtectionPolicy(const ProtectionPolicy& value) { m_newGameSessionProtectionPolicyHasBeenSet = true; m_newGameSessionProtectionPolicy = value; }
|
||||
inline void SetNewGameSessionProtectionPolicy(ProtectionPolicy&& value) { m_newGameSessionProtectionPolicyHasBeenSet = true; m_newGameSessionProtectionPolicy = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithNewGameSessionProtectionPolicy(const ProtectionPolicy& value) { SetNewGameSessionProtectionPolicy(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithNewGameSessionProtectionPolicy(ProtectionPolicy&& value) { SetNewGameSessionProtectionPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A policy that limits the number of game sessions that each individual player
|
||||
* can create on instances in this fleet. The limit applies for a specified span of
|
||||
* time.</p>
|
||||
*/
|
||||
inline const GameSessionCreationLimitPolicy& GetGameSessionCreationLimitPolicy() const{ return m_gameSessionCreationLimitPolicy; }
|
||||
inline bool GameSessionCreationLimitPolicyHasBeenSet() const { return m_gameSessionCreationLimitPolicyHasBeenSet; }
|
||||
inline void SetGameSessionCreationLimitPolicy(const GameSessionCreationLimitPolicy& value) { m_gameSessionCreationLimitPolicyHasBeenSet = true; m_gameSessionCreationLimitPolicy = value; }
|
||||
inline void SetGameSessionCreationLimitPolicy(GameSessionCreationLimitPolicy&& value) { m_gameSessionCreationLimitPolicyHasBeenSet = true; m_gameSessionCreationLimitPolicy = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithGameSessionCreationLimitPolicy(const GameSessionCreationLimitPolicy& value) { SetGameSessionCreationLimitPolicy(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithGameSessionCreationLimitPolicy(GameSessionCreationLimitPolicy&& value) { SetGameSessionCreationLimitPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A method for collecting container logs for the fleet. Amazon GameLift saves
|
||||
* all standard output for each container in logs, including game session logs. You
|
||||
* can select from the following methods: </p> <ul> <li> <p>
|
||||
* <code>CLOUDWATCH</code> -- Send logs to an Amazon CloudWatch log group that you
|
||||
* define. Each container emits a log stream, which is organized in the log group.
|
||||
* </p> </li> <li> <p> <code>S3</code> -- Store logs in an Amazon S3 bucket that
|
||||
* you define.</p> </li> <li> <p> <code>NONE</code> -- Don't collect container
|
||||
* logs.</p> </li> </ul> <p>By default, this property is set to
|
||||
* <code>CLOUDWATCH</code>. </p> <p>Amazon GameLift requires permissions to send
|
||||
* logs other Amazon Web Services services in your account. These permissions are
|
||||
* included in the IAM fleet role for this container fleet (see
|
||||
* <code>FleetRoleArn)</code>.</p>
|
||||
*/
|
||||
inline const LogConfiguration& GetLogConfiguration() const{ return m_logConfiguration; }
|
||||
inline bool LogConfigurationHasBeenSet() const { return m_logConfigurationHasBeenSet; }
|
||||
inline void SetLogConfiguration(const LogConfiguration& value) { m_logConfigurationHasBeenSet = true; m_logConfiguration = value; }
|
||||
inline void SetLogConfiguration(LogConfiguration&& value) { m_logConfigurationHasBeenSet = true; m_logConfiguration = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithLogConfiguration(const LogConfiguration& value) { SetLogConfiguration(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithLogConfiguration(LogConfiguration&& value) { SetLogConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new fleet resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateContainerFleetRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateContainerFleetRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateContainerFleetRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetRoleArn;
|
||||
bool m_fleetRoleArnHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameServerContainerGroupDefinitionName;
|
||||
bool m_gameServerContainerGroupDefinitionNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_perInstanceContainerGroupDefinitionName;
|
||||
bool m_perInstanceContainerGroupDefinitionNameHasBeenSet = false;
|
||||
|
||||
ConnectionPortRange m_instanceConnectionPortRange;
|
||||
bool m_instanceConnectionPortRangeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<IpPermission> m_instanceInboundPermissions;
|
||||
bool m_instanceInboundPermissionsHasBeenSet = false;
|
||||
|
||||
int m_gameServerContainerGroupsPerInstance;
|
||||
bool m_gameServerContainerGroupsPerInstanceHasBeenSet = false;
|
||||
|
||||
Aws::String m_instanceType;
|
||||
bool m_instanceTypeHasBeenSet = false;
|
||||
|
||||
ContainerFleetBillingType m_billingType;
|
||||
bool m_billingTypeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<LocationConfiguration> m_locations;
|
||||
bool m_locationsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_metricGroups;
|
||||
bool m_metricGroupsHasBeenSet = false;
|
||||
|
||||
ProtectionPolicy m_newGameSessionProtectionPolicy;
|
||||
bool m_newGameSessionProtectionPolicyHasBeenSet = false;
|
||||
|
||||
GameSessionCreationLimitPolicy m_gameSessionCreationLimitPolicy;
|
||||
bool m_gameSessionCreationLimitPolicyHasBeenSet = false;
|
||||
|
||||
LogConfiguration m_logConfiguration;
|
||||
bool m_logConfigurationHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/ContainerFleet.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateContainerFleetResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateContainerFleetResult();
|
||||
AWS_GAMELIFT_API CreateContainerFleetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateContainerFleetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The properties for the new container fleet, including current status. All
|
||||
* fleets are initially placed in <code>PENDING</code> status. </p>
|
||||
*/
|
||||
inline const ContainerFleet& GetContainerFleet() const{ return m_containerFleet; }
|
||||
inline void SetContainerFleet(const ContainerFleet& value) { m_containerFleet = value; }
|
||||
inline void SetContainerFleet(ContainerFleet&& value) { m_containerFleet = std::move(value); }
|
||||
inline CreateContainerFleetResult& WithContainerFleet(const ContainerFleet& value) { SetContainerFleet(value); return *this;}
|
||||
inline CreateContainerFleetResult& WithContainerFleet(ContainerFleet&& value) { SetContainerFleet(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateContainerFleetResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateContainerFleetResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateContainerFleetResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ContainerFleet m_containerFleet;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,217 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/ContainerGroupType.h>
|
||||
#include <aws/gamelift/model/GameServerContainerDefinitionInput.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/ContainerOperatingSystem.h>
|
||||
#include <aws/gamelift/model/SupportContainerDefinitionInput.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateContainerGroupDefinitionRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateContainerGroupDefinitionRequest();
|
||||
|
||||
// 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 "CreateContainerGroupDefinition"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive identifier for the container group definition. The name value
|
||||
* must be unique in an Amazon Web Services Region.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of container group being defined. Container group type determines
|
||||
* how Amazon GameLift deploys the container group on each fleet instance.</p>
|
||||
* <p>Default value: <code>GAME_SERVER</code> </p>
|
||||
*/
|
||||
inline const ContainerGroupType& GetContainerGroupType() const{ return m_containerGroupType; }
|
||||
inline bool ContainerGroupTypeHasBeenSet() const { return m_containerGroupTypeHasBeenSet; }
|
||||
inline void SetContainerGroupType(const ContainerGroupType& value) { m_containerGroupTypeHasBeenSet = true; m_containerGroupType = value; }
|
||||
inline void SetContainerGroupType(ContainerGroupType&& value) { m_containerGroupTypeHasBeenSet = true; m_containerGroupType = std::move(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithContainerGroupType(const ContainerGroupType& value) { SetContainerGroupType(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithContainerGroupType(ContainerGroupType&& value) { SetContainerGroupType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum amount of memory (in MiB) to allocate to the container group. All
|
||||
* containers in the group share this memory. If you specify memory limits for an
|
||||
* individual container, the total value must be greater than any individual
|
||||
* container's memory limit.</p> <p>Default value: 1024</p>
|
||||
*/
|
||||
inline int GetTotalMemoryLimitMebibytes() const{ return m_totalMemoryLimitMebibytes; }
|
||||
inline bool TotalMemoryLimitMebibytesHasBeenSet() const { return m_totalMemoryLimitMebibytesHasBeenSet; }
|
||||
inline void SetTotalMemoryLimitMebibytes(int value) { m_totalMemoryLimitMebibytesHasBeenSet = true; m_totalMemoryLimitMebibytes = value; }
|
||||
inline CreateContainerGroupDefinitionRequest& WithTotalMemoryLimitMebibytes(int value) { SetTotalMemoryLimitMebibytes(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum amount of vCPU units to allocate to the container group (1 vCPU
|
||||
* is equal to 1024 CPU units). All containers in the group share this memory. If
|
||||
* you specify vCPU limits for individual containers, the total value must be equal
|
||||
* to or greater than the sum of the CPU limits for all containers in the
|
||||
* group.</p> <p>Default value: 1</p>
|
||||
*/
|
||||
inline double GetTotalVcpuLimit() const{ return m_totalVcpuLimit; }
|
||||
inline bool TotalVcpuLimitHasBeenSet() const { return m_totalVcpuLimitHasBeenSet; }
|
||||
inline void SetTotalVcpuLimit(double value) { m_totalVcpuLimitHasBeenSet = true; m_totalVcpuLimit = value; }
|
||||
inline CreateContainerGroupDefinitionRequest& WithTotalVcpuLimit(double value) { SetTotalVcpuLimit(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The definition for the game server container in this group. Define a game
|
||||
* server container only when the container group type is <code>GAME_SERVER</code>.
|
||||
* Game server containers specify a container image with your game server build.
|
||||
* You can pass in your container definitions as a JSON file.</p>
|
||||
*/
|
||||
inline const GameServerContainerDefinitionInput& GetGameServerContainerDefinition() const{ return m_gameServerContainerDefinition; }
|
||||
inline bool GameServerContainerDefinitionHasBeenSet() const { return m_gameServerContainerDefinitionHasBeenSet; }
|
||||
inline void SetGameServerContainerDefinition(const GameServerContainerDefinitionInput& value) { m_gameServerContainerDefinitionHasBeenSet = true; m_gameServerContainerDefinition = value; }
|
||||
inline void SetGameServerContainerDefinition(GameServerContainerDefinitionInput&& value) { m_gameServerContainerDefinitionHasBeenSet = true; m_gameServerContainerDefinition = std::move(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithGameServerContainerDefinition(const GameServerContainerDefinitionInput& value) { SetGameServerContainerDefinition(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithGameServerContainerDefinition(GameServerContainerDefinitionInput&& value) { SetGameServerContainerDefinition(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>One or more definition for support containers in this group. You can define a
|
||||
* support container in any type of container group. You can pass in your container
|
||||
* definitions as a JSON file.</p>
|
||||
*/
|
||||
inline const Aws::Vector<SupportContainerDefinitionInput>& GetSupportContainerDefinitions() const{ return m_supportContainerDefinitions; }
|
||||
inline bool SupportContainerDefinitionsHasBeenSet() const { return m_supportContainerDefinitionsHasBeenSet; }
|
||||
inline void SetSupportContainerDefinitions(const Aws::Vector<SupportContainerDefinitionInput>& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions = value; }
|
||||
inline void SetSupportContainerDefinitions(Aws::Vector<SupportContainerDefinitionInput>&& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions = std::move(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithSupportContainerDefinitions(const Aws::Vector<SupportContainerDefinitionInput>& value) { SetSupportContainerDefinitions(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithSupportContainerDefinitions(Aws::Vector<SupportContainerDefinitionInput>&& value) { SetSupportContainerDefinitions(std::move(value)); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& AddSupportContainerDefinitions(const SupportContainerDefinitionInput& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions.push_back(value); return *this; }
|
||||
inline CreateContainerGroupDefinitionRequest& AddSupportContainerDefinitions(SupportContainerDefinitionInput&& value) { m_supportContainerDefinitionsHasBeenSet = true; m_supportContainerDefinitions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The platform that all containers in the group use. Containers in a group must
|
||||
* run on the same operating system.</p> <p>Default value:
|
||||
* <code>AMAZON_LINUX_2023</code> </p> <p>Amazon Linux 2 (AL2) will reach
|
||||
* end of support on 6/30/2025. See more details in the <a
|
||||
* href="https://aws.amazon.com/amazon-linux-2/faqs/">Amazon Linux 2 FAQs</a>. For
|
||||
* game servers that are hosted on AL2 and use Amazon GameLift server SDK 4.x,
|
||||
* first update the game server build to server SDK 5.x, and then deploy to AL2023
|
||||
* instances. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-serversdk5-migration.html">
|
||||
* Migrate to Amazon GameLift server SDK version 5.</a> </p>
|
||||
*/
|
||||
inline const ContainerOperatingSystem& GetOperatingSystem() const{ return m_operatingSystem; }
|
||||
inline bool OperatingSystemHasBeenSet() const { return m_operatingSystemHasBeenSet; }
|
||||
inline void SetOperatingSystem(const ContainerOperatingSystem& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = value; }
|
||||
inline void SetOperatingSystem(ContainerOperatingSystem&& value) { m_operatingSystemHasBeenSet = true; m_operatingSystem = std::move(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithOperatingSystem(const ContainerOperatingSystem& value) { SetOperatingSystem(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithOperatingSystem(ContainerOperatingSystem&& value) { SetOperatingSystem(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A description for the initial version of this container group definition.
|
||||
* </p>
|
||||
*/
|
||||
inline const Aws::String& GetVersionDescription() const{ return m_versionDescription; }
|
||||
inline bool VersionDescriptionHasBeenSet() const { return m_versionDescriptionHasBeenSet; }
|
||||
inline void SetVersionDescription(const Aws::String& value) { m_versionDescriptionHasBeenSet = true; m_versionDescription = value; }
|
||||
inline void SetVersionDescription(Aws::String&& value) { m_versionDescriptionHasBeenSet = true; m_versionDescription = std::move(value); }
|
||||
inline void SetVersionDescription(const char* value) { m_versionDescriptionHasBeenSet = true; m_versionDescription.assign(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithVersionDescription(const Aws::String& value) { SetVersionDescription(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithVersionDescription(Aws::String&& value) { SetVersionDescription(std::move(value)); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithVersionDescription(const char* value) { SetVersionDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the container group definition resource. Tags
|
||||
* are developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>. </p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateContainerGroupDefinitionRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateContainerGroupDefinitionRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateContainerGroupDefinitionRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
ContainerGroupType m_containerGroupType;
|
||||
bool m_containerGroupTypeHasBeenSet = false;
|
||||
|
||||
int m_totalMemoryLimitMebibytes;
|
||||
bool m_totalMemoryLimitMebibytesHasBeenSet = false;
|
||||
|
||||
double m_totalVcpuLimit;
|
||||
bool m_totalVcpuLimitHasBeenSet = false;
|
||||
|
||||
GameServerContainerDefinitionInput m_gameServerContainerDefinition;
|
||||
bool m_gameServerContainerDefinitionHasBeenSet = false;
|
||||
|
||||
Aws::Vector<SupportContainerDefinitionInput> m_supportContainerDefinitions;
|
||||
bool m_supportContainerDefinitionsHasBeenSet = false;
|
||||
|
||||
ContainerOperatingSystem m_operatingSystem;
|
||||
bool m_operatingSystemHasBeenSet = false;
|
||||
|
||||
Aws::String m_versionDescription;
|
||||
bool m_versionDescriptionHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/ContainerGroupDefinition.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateContainerGroupDefinitionResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateContainerGroupDefinitionResult();
|
||||
AWS_GAMELIFT_API CreateContainerGroupDefinitionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateContainerGroupDefinitionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The properties of the new container group definition resource. You can use
|
||||
* this resource to create a container fleet.</p>
|
||||
*/
|
||||
inline const ContainerGroupDefinition& GetContainerGroupDefinition() const{ return m_containerGroupDefinition; }
|
||||
inline void SetContainerGroupDefinition(const ContainerGroupDefinition& value) { m_containerGroupDefinition = value; }
|
||||
inline void SetContainerGroupDefinition(ContainerGroupDefinition&& value) { m_containerGroupDefinition = std::move(value); }
|
||||
inline CreateContainerGroupDefinitionResult& WithContainerGroupDefinition(const ContainerGroupDefinition& value) { SetContainerGroupDefinition(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionResult& WithContainerGroupDefinition(ContainerGroupDefinition&& value) { SetContainerGroupDefinition(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateContainerGroupDefinitionResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateContainerGroupDefinitionResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateContainerGroupDefinitionResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
ContainerGroupDefinition m_containerGroupDefinition;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,81 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/LocationConfiguration.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateFleetLocationsRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateFleetLocationsRequest();
|
||||
|
||||
// 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 "CreateFleetLocations"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet to add locations to. You can use either the
|
||||
* fleet ID or ARN value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline CreateFleetLocationsRequest& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline CreateFleetLocationsRequest& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline CreateFleetLocationsRequest& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of locations to deploy additional instances to and manage as part of
|
||||
* the fleet. You can add any Amazon GameLift-supported Amazon Web Services Region
|
||||
* as a remote location, in the form of an Amazon Web Services Region code such as
|
||||
* <code>us-west-2</code>. </p>
|
||||
*/
|
||||
inline const Aws::Vector<LocationConfiguration>& GetLocations() const{ return m_locations; }
|
||||
inline bool LocationsHasBeenSet() const { return m_locationsHasBeenSet; }
|
||||
inline void SetLocations(const Aws::Vector<LocationConfiguration>& value) { m_locationsHasBeenSet = true; m_locations = value; }
|
||||
inline void SetLocations(Aws::Vector<LocationConfiguration>&& value) { m_locationsHasBeenSet = true; m_locations = std::move(value); }
|
||||
inline CreateFleetLocationsRequest& WithLocations(const Aws::Vector<LocationConfiguration>& value) { SetLocations(value); return *this;}
|
||||
inline CreateFleetLocationsRequest& WithLocations(Aws::Vector<LocationConfiguration>&& value) { SetLocations(std::move(value)); return *this;}
|
||||
inline CreateFleetLocationsRequest& AddLocations(const LocationConfiguration& value) { m_locationsHasBeenSet = true; m_locations.push_back(value); return *this; }
|
||||
inline CreateFleetLocationsRequest& AddLocations(LocationConfiguration&& value) { m_locationsHasBeenSet = true; m_locations.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<LocationConfiguration> m_locations;
|
||||
bool m_locationsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,109 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/LocationState.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateFleetLocationsResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateFleetLocationsResult();
|
||||
AWS_GAMELIFT_API CreateFleetLocationsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateFleetLocationsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet that was updated with new locations.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetId.assign(value); }
|
||||
inline CreateFleetLocationsResult& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline CreateFleetLocationsResult& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline CreateFleetLocationsResult& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to a Amazon GameLift fleet resource and uniquely identifies it.
|
||||
* ARNs are unique across all Regions. Format is
|
||||
* <code>arn:aws:gamelift:<region>::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912</code>.
|
||||
* </p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetArn() const{ return m_fleetArn; }
|
||||
inline void SetFleetArn(const Aws::String& value) { m_fleetArn = value; }
|
||||
inline void SetFleetArn(Aws::String&& value) { m_fleetArn = std::move(value); }
|
||||
inline void SetFleetArn(const char* value) { m_fleetArn.assign(value); }
|
||||
inline CreateFleetLocationsResult& WithFleetArn(const Aws::String& value) { SetFleetArn(value); return *this;}
|
||||
inline CreateFleetLocationsResult& WithFleetArn(Aws::String&& value) { SetFleetArn(std::move(value)); return *this;}
|
||||
inline CreateFleetLocationsResult& WithFleetArn(const char* value) { SetFleetArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The remote locations that are being added to the fleet, and the life-cycle
|
||||
* status of each location. For new locations, the status is set to
|
||||
* <code>NEW</code>. During location creation, Amazon GameLift updates each
|
||||
* location's status as instances are deployed there and prepared for game hosting.
|
||||
* This list does not include the fleet home Region or any remote locations that
|
||||
* were already added to the fleet.</p>
|
||||
*/
|
||||
inline const Aws::Vector<LocationState>& GetLocationStates() const{ return m_locationStates; }
|
||||
inline void SetLocationStates(const Aws::Vector<LocationState>& value) { m_locationStates = value; }
|
||||
inline void SetLocationStates(Aws::Vector<LocationState>&& value) { m_locationStates = std::move(value); }
|
||||
inline CreateFleetLocationsResult& WithLocationStates(const Aws::Vector<LocationState>& value) { SetLocationStates(value); return *this;}
|
||||
inline CreateFleetLocationsResult& WithLocationStates(Aws::Vector<LocationState>&& value) { SetLocationStates(std::move(value)); return *this;}
|
||||
inline CreateFleetLocationsResult& AddLocationStates(const LocationState& value) { m_locationStates.push_back(value); return *this; }
|
||||
inline CreateFleetLocationsResult& AddLocationStates(LocationState&& value) { m_locationStates.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateFleetLocationsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateFleetLocationsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateFleetLocationsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
|
||||
Aws::String m_fleetArn;
|
||||
|
||||
Aws::Vector<LocationState> m_locationStates;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,540 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/EC2InstanceType.h>
|
||||
#include <aws/gamelift/model/ProtectionPolicy.h>
|
||||
#include <aws/gamelift/model/RuntimeConfiguration.h>
|
||||
#include <aws/gamelift/model/ResourceCreationLimitPolicy.h>
|
||||
#include <aws/gamelift/model/FleetType.h>
|
||||
#include <aws/gamelift/model/CertificateConfiguration.h>
|
||||
#include <aws/gamelift/model/ComputeType.h>
|
||||
#include <aws/gamelift/model/AnywhereConfiguration.h>
|
||||
#include <aws/gamelift/model/InstanceRoleCredentialsProvider.h>
|
||||
#include <aws/gamelift/model/IpPermission.h>
|
||||
#include <aws/gamelift/model/LocationConfiguration.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateFleetRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateFleetRequest();
|
||||
|
||||
// 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;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with a fleet. Fleet names do not need
|
||||
* to be unique.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateFleetRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateFleetRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A description for the fleet.</p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateFleetRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateFleetRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for a custom game server build to be deployed to a
|
||||
* fleet with compute type <code>EC2</code>. You can use either the build ID or
|
||||
* ARN. The build must be uploaded to Amazon GameLift and in <code>READY</code>
|
||||
* status. This fleet property can't be changed after the fleet is created.</p>
|
||||
*/
|
||||
inline const Aws::String& GetBuildId() const{ return m_buildId; }
|
||||
inline bool BuildIdHasBeenSet() const { return m_buildIdHasBeenSet; }
|
||||
inline void SetBuildId(const Aws::String& value) { m_buildIdHasBeenSet = true; m_buildId = value; }
|
||||
inline void SetBuildId(Aws::String&& value) { m_buildIdHasBeenSet = true; m_buildId = std::move(value); }
|
||||
inline void SetBuildId(const char* value) { m_buildIdHasBeenSet = true; m_buildId.assign(value); }
|
||||
inline CreateFleetRequest& WithBuildId(const Aws::String& value) { SetBuildId(value); return *this;}
|
||||
inline CreateFleetRequest& WithBuildId(Aws::String&& value) { SetBuildId(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithBuildId(const char* value) { SetBuildId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for a Realtime configuration script to be deployed to a
|
||||
* fleet with compute type <code>EC2</code>. You can use either the script ID or
|
||||
* ARN. Scripts must be uploaded to Amazon GameLift prior to creating the fleet.
|
||||
* This fleet property can't be changed after the fleet is created.</p>
|
||||
*/
|
||||
inline const Aws::String& GetScriptId() const{ return m_scriptId; }
|
||||
inline bool ScriptIdHasBeenSet() const { return m_scriptIdHasBeenSet; }
|
||||
inline void SetScriptId(const Aws::String& value) { m_scriptIdHasBeenSet = true; m_scriptId = value; }
|
||||
inline void SetScriptId(Aws::String&& value) { m_scriptIdHasBeenSet = true; m_scriptId = std::move(value); }
|
||||
inline void SetScriptId(const char* value) { m_scriptIdHasBeenSet = true; m_scriptId.assign(value); }
|
||||
inline CreateFleetRequest& WithScriptId(const Aws::String& value) { SetScriptId(value); return *this;}
|
||||
inline CreateFleetRequest& WithScriptId(Aws::String&& value) { SetScriptId(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithScriptId(const char* value) { SetScriptId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> <b>This parameter is no longer used.</b> Specify a server launch path using
|
||||
* the <code>RuntimeConfiguration</code> parameter. Requests that use this
|
||||
* parameter instead continue to be valid.</p>
|
||||
*/
|
||||
inline const Aws::String& GetServerLaunchPath() const{ return m_serverLaunchPath; }
|
||||
inline bool ServerLaunchPathHasBeenSet() const { return m_serverLaunchPathHasBeenSet; }
|
||||
inline void SetServerLaunchPath(const Aws::String& value) { m_serverLaunchPathHasBeenSet = true; m_serverLaunchPath = value; }
|
||||
inline void SetServerLaunchPath(Aws::String&& value) { m_serverLaunchPathHasBeenSet = true; m_serverLaunchPath = std::move(value); }
|
||||
inline void SetServerLaunchPath(const char* value) { m_serverLaunchPathHasBeenSet = true; m_serverLaunchPath.assign(value); }
|
||||
inline CreateFleetRequest& WithServerLaunchPath(const Aws::String& value) { SetServerLaunchPath(value); return *this;}
|
||||
inline CreateFleetRequest& WithServerLaunchPath(Aws::String&& value) { SetServerLaunchPath(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithServerLaunchPath(const char* value) { SetServerLaunchPath(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> <b>This parameter is no longer used.</b> Specify server launch parameters
|
||||
* using the <code>RuntimeConfiguration</code> parameter. Requests that use this
|
||||
* parameter instead continue to be valid.</p>
|
||||
*/
|
||||
inline const Aws::String& GetServerLaunchParameters() const{ return m_serverLaunchParameters; }
|
||||
inline bool ServerLaunchParametersHasBeenSet() const { return m_serverLaunchParametersHasBeenSet; }
|
||||
inline void SetServerLaunchParameters(const Aws::String& value) { m_serverLaunchParametersHasBeenSet = true; m_serverLaunchParameters = value; }
|
||||
inline void SetServerLaunchParameters(Aws::String&& value) { m_serverLaunchParametersHasBeenSet = true; m_serverLaunchParameters = std::move(value); }
|
||||
inline void SetServerLaunchParameters(const char* value) { m_serverLaunchParametersHasBeenSet = true; m_serverLaunchParameters.assign(value); }
|
||||
inline CreateFleetRequest& WithServerLaunchParameters(const Aws::String& value) { SetServerLaunchParameters(value); return *this;}
|
||||
inline CreateFleetRequest& WithServerLaunchParameters(Aws::String&& value) { SetServerLaunchParameters(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithServerLaunchParameters(const char* value) { SetServerLaunchParameters(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> <b>This parameter is no longer used.</b> To specify where Amazon GameLift
|
||||
* should store log files once a server process shuts down, use the Amazon GameLift
|
||||
* server API <code>ProcessReady()</code> and specify one or more directory paths
|
||||
* in <code>logParameters</code>. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-initialize">Initialize
|
||||
* the server process</a> in the <i>Amazon GameLift Developer Guide</i>. </p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetLogPaths() const{ return m_logPaths; }
|
||||
inline bool LogPathsHasBeenSet() const { return m_logPathsHasBeenSet; }
|
||||
inline void SetLogPaths(const Aws::Vector<Aws::String>& value) { m_logPathsHasBeenSet = true; m_logPaths = value; }
|
||||
inline void SetLogPaths(Aws::Vector<Aws::String>&& value) { m_logPathsHasBeenSet = true; m_logPaths = std::move(value); }
|
||||
inline CreateFleetRequest& WithLogPaths(const Aws::Vector<Aws::String>& value) { SetLogPaths(value); return *this;}
|
||||
inline CreateFleetRequest& WithLogPaths(Aws::Vector<Aws::String>&& value) { SetLogPaths(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& AddLogPaths(const Aws::String& value) { m_logPathsHasBeenSet = true; m_logPaths.push_back(value); return *this; }
|
||||
inline CreateFleetRequest& AddLogPaths(Aws::String&& value) { m_logPathsHasBeenSet = true; m_logPaths.push_back(std::move(value)); return *this; }
|
||||
inline CreateFleetRequest& AddLogPaths(const char* value) { m_logPathsHasBeenSet = true; m_logPaths.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon GameLift-supported Amazon EC2 instance type to use with managed
|
||||
* EC2 fleets. Instance type determines the computing resources that will be used
|
||||
* to host your game servers, including CPU, memory, storage, and networking
|
||||
* capacity. See <a href="http://aws.amazon.com/ec2/instance-types/">Amazon Elastic
|
||||
* Compute Cloud Instance Types</a> for detailed descriptions of Amazon EC2
|
||||
* instance types.</p>
|
||||
*/
|
||||
inline const EC2InstanceType& GetEC2InstanceType() const{ return m_eC2InstanceType; }
|
||||
inline bool EC2InstanceTypeHasBeenSet() const { return m_eC2InstanceTypeHasBeenSet; }
|
||||
inline void SetEC2InstanceType(const EC2InstanceType& value) { m_eC2InstanceTypeHasBeenSet = true; m_eC2InstanceType = value; }
|
||||
inline void SetEC2InstanceType(EC2InstanceType&& value) { m_eC2InstanceTypeHasBeenSet = true; m_eC2InstanceType = std::move(value); }
|
||||
inline CreateFleetRequest& WithEC2InstanceType(const EC2InstanceType& value) { SetEC2InstanceType(value); return *this;}
|
||||
inline CreateFleetRequest& WithEC2InstanceType(EC2InstanceType&& value) { SetEC2InstanceType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The IP address ranges and port settings that allow inbound traffic to access
|
||||
* game server processes and other processes on this fleet. Set this parameter for
|
||||
* managed EC2 fleets. You can leave this parameter empty when creating the fleet,
|
||||
* but you must call <a>UpdateFleetPortSettings</a> to set it before players can
|
||||
* connect to game sessions. As a best practice, we recommend opening ports for
|
||||
* remote access only when you need them and closing them when you're finished. For
|
||||
* Realtime Servers fleets, Amazon GameLift automatically sets TCP and UDP
|
||||
* ranges.</p>
|
||||
*/
|
||||
inline const Aws::Vector<IpPermission>& GetEC2InboundPermissions() const{ return m_eC2InboundPermissions; }
|
||||
inline bool EC2InboundPermissionsHasBeenSet() const { return m_eC2InboundPermissionsHasBeenSet; }
|
||||
inline void SetEC2InboundPermissions(const Aws::Vector<IpPermission>& value) { m_eC2InboundPermissionsHasBeenSet = true; m_eC2InboundPermissions = value; }
|
||||
inline void SetEC2InboundPermissions(Aws::Vector<IpPermission>&& value) { m_eC2InboundPermissionsHasBeenSet = true; m_eC2InboundPermissions = std::move(value); }
|
||||
inline CreateFleetRequest& WithEC2InboundPermissions(const Aws::Vector<IpPermission>& value) { SetEC2InboundPermissions(value); return *this;}
|
||||
inline CreateFleetRequest& WithEC2InboundPermissions(Aws::Vector<IpPermission>&& value) { SetEC2InboundPermissions(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& AddEC2InboundPermissions(const IpPermission& value) { m_eC2InboundPermissionsHasBeenSet = true; m_eC2InboundPermissions.push_back(value); return *this; }
|
||||
inline CreateFleetRequest& AddEC2InboundPermissions(IpPermission&& value) { m_eC2InboundPermissionsHasBeenSet = true; m_eC2InboundPermissions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The status of termination protection for active game sessions on the fleet.
|
||||
* By default, this property is set to <code>NoProtection</code>. You can also set
|
||||
* game session protection for an individual game session by calling <a
|
||||
* href="gamelift/latest/apireference/API_UpdateGameSession.html">UpdateGameSession</a>.</p>
|
||||
* <ul> <li> <p> <b>NoProtection</b> - Game sessions can be terminated during
|
||||
* active gameplay as a result of a scale-down event. </p> </li> <li> <p>
|
||||
* <b>FullProtection</b> - Game sessions in <code>ACTIVE</code> status cannot be
|
||||
* terminated during a scale-down event.</p> </li> </ul>
|
||||
*/
|
||||
inline const ProtectionPolicy& GetNewGameSessionProtectionPolicy() const{ return m_newGameSessionProtectionPolicy; }
|
||||
inline bool NewGameSessionProtectionPolicyHasBeenSet() const { return m_newGameSessionProtectionPolicyHasBeenSet; }
|
||||
inline void SetNewGameSessionProtectionPolicy(const ProtectionPolicy& value) { m_newGameSessionProtectionPolicyHasBeenSet = true; m_newGameSessionProtectionPolicy = value; }
|
||||
inline void SetNewGameSessionProtectionPolicy(ProtectionPolicy&& value) { m_newGameSessionProtectionPolicyHasBeenSet = true; m_newGameSessionProtectionPolicy = std::move(value); }
|
||||
inline CreateFleetRequest& WithNewGameSessionProtectionPolicy(const ProtectionPolicy& value) { SetNewGameSessionProtectionPolicy(value); return *this;}
|
||||
inline CreateFleetRequest& WithNewGameSessionProtectionPolicy(ProtectionPolicy&& value) { SetNewGameSessionProtectionPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Instructions for how to launch and run server processes on the fleet. Set
|
||||
* runtime configuration for managed EC2 fleets. For an Anywhere fleets, set this
|
||||
* parameter only if the fleet is running the Amazon GameLift Agent. The runtime
|
||||
* configuration defines one or more server process configurations. Each server
|
||||
* process identifies a game executable or Realtime script file and the number of
|
||||
* processes to run concurrently. </p> <p>This parameter replaces the
|
||||
* parameters <code>ServerLaunchPath</code> and
|
||||
* <code>ServerLaunchParameters</code>, which are still supported for backward
|
||||
* compatibility.</p>
|
||||
*/
|
||||
inline const RuntimeConfiguration& GetRuntimeConfiguration() const{ return m_runtimeConfiguration; }
|
||||
inline bool RuntimeConfigurationHasBeenSet() const { return m_runtimeConfigurationHasBeenSet; }
|
||||
inline void SetRuntimeConfiguration(const RuntimeConfiguration& value) { m_runtimeConfigurationHasBeenSet = true; m_runtimeConfiguration = value; }
|
||||
inline void SetRuntimeConfiguration(RuntimeConfiguration&& value) { m_runtimeConfigurationHasBeenSet = true; m_runtimeConfiguration = std::move(value); }
|
||||
inline CreateFleetRequest& WithRuntimeConfiguration(const RuntimeConfiguration& value) { SetRuntimeConfiguration(value); return *this;}
|
||||
inline CreateFleetRequest& WithRuntimeConfiguration(RuntimeConfiguration&& value) { SetRuntimeConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A policy that limits the number of game sessions that an individual player
|
||||
* can create on instances in this fleet within a specified span of time.</p>
|
||||
*/
|
||||
inline const ResourceCreationLimitPolicy& GetResourceCreationLimitPolicy() const{ return m_resourceCreationLimitPolicy; }
|
||||
inline bool ResourceCreationLimitPolicyHasBeenSet() const { return m_resourceCreationLimitPolicyHasBeenSet; }
|
||||
inline void SetResourceCreationLimitPolicy(const ResourceCreationLimitPolicy& value) { m_resourceCreationLimitPolicyHasBeenSet = true; m_resourceCreationLimitPolicy = value; }
|
||||
inline void SetResourceCreationLimitPolicy(ResourceCreationLimitPolicy&& value) { m_resourceCreationLimitPolicyHasBeenSet = true; m_resourceCreationLimitPolicy = std::move(value); }
|
||||
inline CreateFleetRequest& WithResourceCreationLimitPolicy(const ResourceCreationLimitPolicy& value) { SetResourceCreationLimitPolicy(value); return *this;}
|
||||
inline CreateFleetRequest& WithResourceCreationLimitPolicy(ResourceCreationLimitPolicy&& value) { SetResourceCreationLimitPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The name of an Amazon Web Services CloudWatch metric group to add this fleet
|
||||
* to. A metric group is used to aggregate the metrics for multiple fleets. You can
|
||||
* specify an existing metric group name or set a new name to create a new metric
|
||||
* group. A fleet can be included in only one metric group at a time. </p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetMetricGroups() const{ return m_metricGroups; }
|
||||
inline bool MetricGroupsHasBeenSet() const { return m_metricGroupsHasBeenSet; }
|
||||
inline void SetMetricGroups(const Aws::Vector<Aws::String>& value) { m_metricGroupsHasBeenSet = true; m_metricGroups = value; }
|
||||
inline void SetMetricGroups(Aws::Vector<Aws::String>&& value) { m_metricGroupsHasBeenSet = true; m_metricGroups = std::move(value); }
|
||||
inline CreateFleetRequest& WithMetricGroups(const Aws::Vector<Aws::String>& value) { SetMetricGroups(value); return *this;}
|
||||
inline CreateFleetRequest& WithMetricGroups(Aws::Vector<Aws::String>&& value) { SetMetricGroups(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& AddMetricGroups(const Aws::String& value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(value); return *this; }
|
||||
inline CreateFleetRequest& AddMetricGroups(Aws::String&& value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(std::move(value)); return *this; }
|
||||
inline CreateFleetRequest& AddMetricGroups(const char* value) { m_metricGroupsHasBeenSet = true; m_metricGroups.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Used when peering your Amazon GameLift fleet with a VPC, the unique
|
||||
* identifier for the Amazon Web Services account that owns the VPC. You can find
|
||||
* your account ID in the Amazon Web Services Management Console under account
|
||||
* settings. </p>
|
||||
*/
|
||||
inline const Aws::String& GetPeerVpcAwsAccountId() const{ return m_peerVpcAwsAccountId; }
|
||||
inline bool PeerVpcAwsAccountIdHasBeenSet() const { return m_peerVpcAwsAccountIdHasBeenSet; }
|
||||
inline void SetPeerVpcAwsAccountId(const Aws::String& value) { m_peerVpcAwsAccountIdHasBeenSet = true; m_peerVpcAwsAccountId = value; }
|
||||
inline void SetPeerVpcAwsAccountId(Aws::String&& value) { m_peerVpcAwsAccountIdHasBeenSet = true; m_peerVpcAwsAccountId = std::move(value); }
|
||||
inline void SetPeerVpcAwsAccountId(const char* value) { m_peerVpcAwsAccountIdHasBeenSet = true; m_peerVpcAwsAccountId.assign(value); }
|
||||
inline CreateFleetRequest& WithPeerVpcAwsAccountId(const Aws::String& value) { SetPeerVpcAwsAccountId(value); return *this;}
|
||||
inline CreateFleetRequest& WithPeerVpcAwsAccountId(Aws::String&& value) { SetPeerVpcAwsAccountId(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithPeerVpcAwsAccountId(const char* value) { SetPeerVpcAwsAccountId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a VPC with resources to be accessed by your Amazon
|
||||
* GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
|
||||
* VPC ID, use the <a href="https://console.aws.amazon.com/vpc/">VPC Dashboard</a>
|
||||
* in the Amazon Web Services Management Console. Learn more about VPC peering in
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html">VPC
|
||||
* Peering with Amazon GameLift Fleets</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPeerVpcId() const{ return m_peerVpcId; }
|
||||
inline bool PeerVpcIdHasBeenSet() const { return m_peerVpcIdHasBeenSet; }
|
||||
inline void SetPeerVpcId(const Aws::String& value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId = value; }
|
||||
inline void SetPeerVpcId(Aws::String&& value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId = std::move(value); }
|
||||
inline void SetPeerVpcId(const char* value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId.assign(value); }
|
||||
inline CreateFleetRequest& WithPeerVpcId(const Aws::String& value) { SetPeerVpcId(value); return *this;}
|
||||
inline CreateFleetRequest& WithPeerVpcId(Aws::String&& value) { SetPeerVpcId(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithPeerVpcId(const char* value) { SetPeerVpcId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates whether to use On-Demand or Spot instances for this fleet. By
|
||||
* default, this property is set to <code>ON_DEMAND</code>. Learn more about when
|
||||
* to use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot">
|
||||
* On-Demand versus Spot Instances</a>. This fleet property can't be changed after
|
||||
* the fleet is created.</p>
|
||||
*/
|
||||
inline const FleetType& GetFleetType() const{ return m_fleetType; }
|
||||
inline bool FleetTypeHasBeenSet() const { return m_fleetTypeHasBeenSet; }
|
||||
inline void SetFleetType(const FleetType& value) { m_fleetTypeHasBeenSet = true; m_fleetType = value; }
|
||||
inline void SetFleetType(FleetType&& value) { m_fleetTypeHasBeenSet = true; m_fleetType = std::move(value); }
|
||||
inline CreateFleetRequest& WithFleetType(const FleetType& value) { SetFleetType(value); return *this;}
|
||||
inline CreateFleetRequest& WithFleetType(FleetType&& value) { SetFleetType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for an IAM role that manages access to your Amazon Web
|
||||
* Services services. With an instance role ARN set, any application that runs on
|
||||
* an instance in this fleet can assume the role, including install scripts, server
|
||||
* processes, and daemons (background processes). Create a role or look up a role's
|
||||
* ARN by using the <a href="https://console.aws.amazon.com/iam/">IAM dashboard</a>
|
||||
* in the Amazon Web Services Management Console. Learn more about using on-box
|
||||
* credentials for your game servers at <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html">
|
||||
* Access external resources from a game server</a>. This fleet property can't be
|
||||
* changed after the fleet is created.</p>
|
||||
*/
|
||||
inline const Aws::String& GetInstanceRoleArn() const{ return m_instanceRoleArn; }
|
||||
inline bool InstanceRoleArnHasBeenSet() const { return m_instanceRoleArnHasBeenSet; }
|
||||
inline void SetInstanceRoleArn(const Aws::String& value) { m_instanceRoleArnHasBeenSet = true; m_instanceRoleArn = value; }
|
||||
inline void SetInstanceRoleArn(Aws::String&& value) { m_instanceRoleArnHasBeenSet = true; m_instanceRoleArn = std::move(value); }
|
||||
inline void SetInstanceRoleArn(const char* value) { m_instanceRoleArnHasBeenSet = true; m_instanceRoleArn.assign(value); }
|
||||
inline CreateFleetRequest& WithInstanceRoleArn(const Aws::String& value) { SetInstanceRoleArn(value); return *this;}
|
||||
inline CreateFleetRequest& WithInstanceRoleArn(Aws::String&& value) { SetInstanceRoleArn(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& WithInstanceRoleArn(const char* value) { SetInstanceRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Prompts Amazon GameLift to generate a TLS/SSL certificate for the fleet.
|
||||
* Amazon GameLift uses the certificates to encrypt traffic between game clients
|
||||
* and the game servers running on Amazon GameLift. By default, the
|
||||
* <code>CertificateConfiguration</code> is <code>DISABLED</code>. You can't change
|
||||
* this property after you create the fleet. </p> <p>Certificate Manager (ACM)
|
||||
* certificates expire after 13 months. Certificate expiration can cause fleets to
|
||||
* fail, preventing players from connecting to instances in the fleet. We recommend
|
||||
* you replace fleets before 13 months, consider using fleet aliases for a smooth
|
||||
* transition.</p> <p>ACM isn't available in all Amazon Web Services
|
||||
* regions. A fleet creation request with certificate generation enabled in an
|
||||
* unsupported Region, fails with a 4xx error. For more information about the
|
||||
* supported Regions, see <a
|
||||
* href="https://docs.aws.amazon.com/acm/latest/userguide/acm-regions.html">Supported
|
||||
* Regions</a> in the <i>Certificate Manager User Guide</i>.</p>
|
||||
*/
|
||||
inline const CertificateConfiguration& GetCertificateConfiguration() const{ return m_certificateConfiguration; }
|
||||
inline bool CertificateConfigurationHasBeenSet() const { return m_certificateConfigurationHasBeenSet; }
|
||||
inline void SetCertificateConfiguration(const CertificateConfiguration& value) { m_certificateConfigurationHasBeenSet = true; m_certificateConfiguration = value; }
|
||||
inline void SetCertificateConfiguration(CertificateConfiguration&& value) { m_certificateConfigurationHasBeenSet = true; m_certificateConfiguration = std::move(value); }
|
||||
inline CreateFleetRequest& WithCertificateConfiguration(const CertificateConfiguration& value) { SetCertificateConfiguration(value); return *this;}
|
||||
inline CreateFleetRequest& WithCertificateConfiguration(CertificateConfiguration&& value) { SetCertificateConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of remote locations to deploy additional instances to and manage as a
|
||||
* multi-location fleet. Use this parameter when creating a fleet in Amazon Web
|
||||
* Services Regions that support multiple locations. You can add any Amazon Web
|
||||
* Services Region or Local Zone that's supported by Amazon GameLift. Provide a
|
||||
* list of one or more Amazon Web Services Region codes, such as
|
||||
* <code>us-west-2</code>, or Local Zone names. When using this parameter, Amazon
|
||||
* GameLift requires you to include your home location in the request. For a list
|
||||
* of supported Regions and Local Zones, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-regions.html">
|
||||
* Amazon GameLift service locations</a> for managed hosting.</p>
|
||||
*/
|
||||
inline const Aws::Vector<LocationConfiguration>& GetLocations() const{ return m_locations; }
|
||||
inline bool LocationsHasBeenSet() const { return m_locationsHasBeenSet; }
|
||||
inline void SetLocations(const Aws::Vector<LocationConfiguration>& value) { m_locationsHasBeenSet = true; m_locations = value; }
|
||||
inline void SetLocations(Aws::Vector<LocationConfiguration>&& value) { m_locationsHasBeenSet = true; m_locations = std::move(value); }
|
||||
inline CreateFleetRequest& WithLocations(const Aws::Vector<LocationConfiguration>& value) { SetLocations(value); return *this;}
|
||||
inline CreateFleetRequest& WithLocations(Aws::Vector<LocationConfiguration>&& value) { SetLocations(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& AddLocations(const LocationConfiguration& value) { m_locationsHasBeenSet = true; m_locations.push_back(value); return *this; }
|
||||
inline CreateFleetRequest& AddLocations(LocationConfiguration&& value) { m_locationsHasBeenSet = true; m_locations.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new fleet resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateFleetRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateFleetRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateFleetRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateFleetRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of compute resource used to host your game servers. </p> <ul> <li>
|
||||
* <p> <code>EC2</code> – The game server build is deployed to Amazon EC2 instances
|
||||
* for cloud hosting. This is the default setting.</p> </li> <li> <p>
|
||||
* <code>ANYWHERE</code> – Your game server and supporting software is deployed to
|
||||
* compute resources that are provided and managed by you. With this compute type,
|
||||
* you can also set the <code>AnywhereConfiguration</code> parameter.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const ComputeType& GetComputeType() const{ return m_computeType; }
|
||||
inline bool ComputeTypeHasBeenSet() const { return m_computeTypeHasBeenSet; }
|
||||
inline void SetComputeType(const ComputeType& value) { m_computeTypeHasBeenSet = true; m_computeType = value; }
|
||||
inline void SetComputeType(ComputeType&& value) { m_computeTypeHasBeenSet = true; m_computeType = std::move(value); }
|
||||
inline CreateFleetRequest& WithComputeType(const ComputeType& value) { SetComputeType(value); return *this;}
|
||||
inline CreateFleetRequest& WithComputeType(ComputeType&& value) { SetComputeType(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Amazon GameLift Anywhere configuration options.</p>
|
||||
*/
|
||||
inline const AnywhereConfiguration& GetAnywhereConfiguration() const{ return m_anywhereConfiguration; }
|
||||
inline bool AnywhereConfigurationHasBeenSet() const { return m_anywhereConfigurationHasBeenSet; }
|
||||
inline void SetAnywhereConfiguration(const AnywhereConfiguration& value) { m_anywhereConfigurationHasBeenSet = true; m_anywhereConfiguration = value; }
|
||||
inline void SetAnywhereConfiguration(AnywhereConfiguration&& value) { m_anywhereConfigurationHasBeenSet = true; m_anywhereConfiguration = std::move(value); }
|
||||
inline CreateFleetRequest& WithAnywhereConfiguration(const AnywhereConfiguration& value) { SetAnywhereConfiguration(value); return *this;}
|
||||
inline CreateFleetRequest& WithAnywhereConfiguration(AnywhereConfiguration&& value) { SetAnywhereConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Prompts Amazon GameLift to generate a shared credentials file for the IAM
|
||||
* role that's defined in <code>InstanceRoleArn</code>. The shared credentials file
|
||||
* is stored on each fleet instance and refreshed as needed. Use shared credentials
|
||||
* for applications that are deployed along with the game server executable, if the
|
||||
* game server is integrated with server SDK version 5.x. For more information
|
||||
* about using shared credentials, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html">
|
||||
* Communicate with other Amazon Web Services resources from your fleets</a>.</p>
|
||||
*/
|
||||
inline const InstanceRoleCredentialsProvider& GetInstanceRoleCredentialsProvider() const{ return m_instanceRoleCredentialsProvider; }
|
||||
inline bool InstanceRoleCredentialsProviderHasBeenSet() const { return m_instanceRoleCredentialsProviderHasBeenSet; }
|
||||
inline void SetInstanceRoleCredentialsProvider(const InstanceRoleCredentialsProvider& value) { m_instanceRoleCredentialsProviderHasBeenSet = true; m_instanceRoleCredentialsProvider = value; }
|
||||
inline void SetInstanceRoleCredentialsProvider(InstanceRoleCredentialsProvider&& value) { m_instanceRoleCredentialsProviderHasBeenSet = true; m_instanceRoleCredentialsProvider = std::move(value); }
|
||||
inline CreateFleetRequest& WithInstanceRoleCredentialsProvider(const InstanceRoleCredentialsProvider& value) { SetInstanceRoleCredentialsProvider(value); return *this;}
|
||||
inline CreateFleetRequest& WithInstanceRoleCredentialsProvider(InstanceRoleCredentialsProvider&& value) { SetInstanceRoleCredentialsProvider(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
Aws::String m_buildId;
|
||||
bool m_buildIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_scriptId;
|
||||
bool m_scriptIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_serverLaunchPath;
|
||||
bool m_serverLaunchPathHasBeenSet = false;
|
||||
|
||||
Aws::String m_serverLaunchParameters;
|
||||
bool m_serverLaunchParametersHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_logPaths;
|
||||
bool m_logPathsHasBeenSet = false;
|
||||
|
||||
EC2InstanceType m_eC2InstanceType;
|
||||
bool m_eC2InstanceTypeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<IpPermission> m_eC2InboundPermissions;
|
||||
bool m_eC2InboundPermissionsHasBeenSet = false;
|
||||
|
||||
ProtectionPolicy m_newGameSessionProtectionPolicy;
|
||||
bool m_newGameSessionProtectionPolicyHasBeenSet = false;
|
||||
|
||||
RuntimeConfiguration m_runtimeConfiguration;
|
||||
bool m_runtimeConfigurationHasBeenSet = false;
|
||||
|
||||
ResourceCreationLimitPolicy m_resourceCreationLimitPolicy;
|
||||
bool m_resourceCreationLimitPolicyHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_metricGroups;
|
||||
bool m_metricGroupsHasBeenSet = false;
|
||||
|
||||
Aws::String m_peerVpcAwsAccountId;
|
||||
bool m_peerVpcAwsAccountIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_peerVpcId;
|
||||
bool m_peerVpcIdHasBeenSet = false;
|
||||
|
||||
FleetType m_fleetType;
|
||||
bool m_fleetTypeHasBeenSet = false;
|
||||
|
||||
Aws::String m_instanceRoleArn;
|
||||
bool m_instanceRoleArnHasBeenSet = false;
|
||||
|
||||
CertificateConfiguration m_certificateConfiguration;
|
||||
bool m_certificateConfigurationHasBeenSet = false;
|
||||
|
||||
Aws::Vector<LocationConfiguration> m_locations;
|
||||
bool m_locationsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
|
||||
ComputeType m_computeType;
|
||||
bool m_computeTypeHasBeenSet = false;
|
||||
|
||||
AnywhereConfiguration m_anywhereConfiguration;
|
||||
bool m_anywhereConfigurationHasBeenSet = false;
|
||||
|
||||
InstanceRoleCredentialsProvider m_instanceRoleCredentialsProvider;
|
||||
bool m_instanceRoleCredentialsProviderHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,89 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/FleetAttributes.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/LocationState.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateFleetResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateFleetResult();
|
||||
AWS_GAMELIFT_API CreateFleetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateFleetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The properties for the new fleet, including the current status. All fleets
|
||||
* are placed in <code>NEW</code> status on creation. </p>
|
||||
*/
|
||||
inline const FleetAttributes& GetFleetAttributes() const{ return m_fleetAttributes; }
|
||||
inline void SetFleetAttributes(const FleetAttributes& value) { m_fleetAttributes = value; }
|
||||
inline void SetFleetAttributes(FleetAttributes&& value) { m_fleetAttributes = std::move(value); }
|
||||
inline CreateFleetResult& WithFleetAttributes(const FleetAttributes& value) { SetFleetAttributes(value); return *this;}
|
||||
inline CreateFleetResult& WithFleetAttributes(FleetAttributes&& value) { SetFleetAttributes(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The fleet's locations and life-cycle status of each location. For new fleets,
|
||||
* the status of all locations is set to <code>NEW</code>. During fleet creation,
|
||||
* Amazon GameLift updates each location status as instances are deployed there and
|
||||
* prepared for game hosting. This list includes an entry for the fleet's home
|
||||
* Region. For fleets with no remote locations, only one entry, representing the
|
||||
* home Region, is returned.</p>
|
||||
*/
|
||||
inline const Aws::Vector<LocationState>& GetLocationStates() const{ return m_locationStates; }
|
||||
inline void SetLocationStates(const Aws::Vector<LocationState>& value) { m_locationStates = value; }
|
||||
inline void SetLocationStates(Aws::Vector<LocationState>&& value) { m_locationStates = std::move(value); }
|
||||
inline CreateFleetResult& WithLocationStates(const Aws::Vector<LocationState>& value) { SetLocationStates(value); return *this;}
|
||||
inline CreateFleetResult& WithLocationStates(Aws::Vector<LocationState>&& value) { SetLocationStates(std::move(value)); return *this;}
|
||||
inline CreateFleetResult& AddLocationStates(const LocationState& value) { m_locationStates.push_back(value); return *this; }
|
||||
inline CreateFleetResult& AddLocationStates(LocationState&& value) { m_locationStates.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateFleetResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateFleetResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateFleetResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
FleetAttributes m_fleetAttributes;
|
||||
|
||||
Aws::Vector<LocationState> m_locationStates;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,297 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/LaunchTemplateSpecification.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/GameServerGroupAutoScalingPolicy.h>
|
||||
#include <aws/gamelift/model/BalancingStrategy.h>
|
||||
#include <aws/gamelift/model/GameServerProtectionPolicy.h>
|
||||
#include <aws/gamelift/model/InstanceDefinition.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateGameServerGroupRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateGameServerGroupRequest();
|
||||
|
||||
// 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 "CreateGameServerGroup"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An identifier for the new game server group. This value is used to generate
|
||||
* unique ARN identifiers for the Amazon EC2 Auto Scaling group and the Amazon
|
||||
* GameLift FleetIQ game server group. The name must be unique per Region per
|
||||
* Amazon Web Services account.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerGroupName() const{ return m_gameServerGroupName; }
|
||||
inline bool GameServerGroupNameHasBeenSet() const { return m_gameServerGroupNameHasBeenSet; }
|
||||
inline void SetGameServerGroupName(const Aws::String& value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName = value; }
|
||||
inline void SetGameServerGroupName(Aws::String&& value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName = std::move(value); }
|
||||
inline void SetGameServerGroupName(const char* value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName.assign(value); }
|
||||
inline CreateGameServerGroupRequest& WithGameServerGroupName(const Aws::String& value) { SetGameServerGroupName(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithGameServerGroupName(Aws::String&& value) { SetGameServerGroupName(std::move(value)); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithGameServerGroupName(const char* value) { SetGameServerGroupName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* for an IAM role that allows Amazon GameLift to access your Amazon EC2 Auto
|
||||
* Scaling groups.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRoleArn() const{ return m_roleArn; }
|
||||
inline bool RoleArnHasBeenSet() const { return m_roleArnHasBeenSet; }
|
||||
inline void SetRoleArn(const Aws::String& value) { m_roleArnHasBeenSet = true; m_roleArn = value; }
|
||||
inline void SetRoleArn(Aws::String&& value) { m_roleArnHasBeenSet = true; m_roleArn = std::move(value); }
|
||||
inline void SetRoleArn(const char* value) { m_roleArnHasBeenSet = true; m_roleArn.assign(value); }
|
||||
inline CreateGameServerGroupRequest& WithRoleArn(const Aws::String& value) { SetRoleArn(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithRoleArn(Aws::String&& value) { SetRoleArn(std::move(value)); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithRoleArn(const char* value) { SetRoleArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The minimum number of instances allowed in the Amazon EC2 Auto Scaling group.
|
||||
* During automatic scaling events, Amazon GameLift FleetIQ and Amazon EC2 do not
|
||||
* scale down the group below this minimum. In production, this value should be set
|
||||
* to at least 1. After the Auto Scaling group is created, update this value
|
||||
* directly in the Auto Scaling group using the Amazon Web Services console or
|
||||
* APIs.</p>
|
||||
*/
|
||||
inline int GetMinSize() const{ return m_minSize; }
|
||||
inline bool MinSizeHasBeenSet() const { return m_minSizeHasBeenSet; }
|
||||
inline void SetMinSize(int value) { m_minSizeHasBeenSet = true; m_minSize = value; }
|
||||
inline CreateGameServerGroupRequest& WithMinSize(int value) { SetMinSize(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum number of instances allowed in the Amazon EC2 Auto Scaling group.
|
||||
* During automatic scaling events, Amazon GameLift FleetIQ and EC2 do not scale up
|
||||
* the group above this maximum. After the Auto Scaling group is created, update
|
||||
* this value directly in the Auto Scaling group using the Amazon Web Services
|
||||
* console or APIs.</p>
|
||||
*/
|
||||
inline int GetMaxSize() const{ return m_maxSize; }
|
||||
inline bool MaxSizeHasBeenSet() const { return m_maxSizeHasBeenSet; }
|
||||
inline void SetMaxSize(int value) { m_maxSizeHasBeenSet = true; m_maxSize = value; }
|
||||
inline CreateGameServerGroupRequest& WithMaxSize(int value) { SetMaxSize(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon EC2 launch template that contains configuration settings and game
|
||||
* server code to be deployed to all instances in the game server group. You can
|
||||
* specify the template using either the template name or ID. For help with
|
||||
* creating a launch template, see <a
|
||||
* href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html">Creating
|
||||
* a Launch Template for an Auto Scaling Group</a> in the <i>Amazon Elastic Compute
|
||||
* Cloud Auto Scaling User Guide</i>. After the Auto Scaling group is created,
|
||||
* update this value directly in the Auto Scaling group using the Amazon Web
|
||||
* Services console or APIs.</p> <p>If you specify network interfaces in
|
||||
* your launch template, you must explicitly set the property
|
||||
* <code>AssociatePublicIpAddress</code> to "true". If no network interface is
|
||||
* specified in the launch template, Amazon GameLift FleetIQ uses your account's
|
||||
* default VPC.</p>
|
||||
*/
|
||||
inline const LaunchTemplateSpecification& GetLaunchTemplate() const{ return m_launchTemplate; }
|
||||
inline bool LaunchTemplateHasBeenSet() const { return m_launchTemplateHasBeenSet; }
|
||||
inline void SetLaunchTemplate(const LaunchTemplateSpecification& value) { m_launchTemplateHasBeenSet = true; m_launchTemplate = value; }
|
||||
inline void SetLaunchTemplate(LaunchTemplateSpecification&& value) { m_launchTemplateHasBeenSet = true; m_launchTemplate = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithLaunchTemplate(const LaunchTemplateSpecification& value) { SetLaunchTemplate(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithLaunchTemplate(LaunchTemplateSpecification&& value) { SetLaunchTemplate(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon EC2 instance types and sizes to use in the Auto Scaling group. The
|
||||
* instance definitions must specify at least two different instance types that are
|
||||
* supported by Amazon GameLift FleetIQ. For more information on instance types,
|
||||
* see <a
|
||||
* href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">EC2
|
||||
* Instance Types</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. You
|
||||
* can optionally specify capacity weighting for each instance type. If no weight
|
||||
* value is specified for an instance type, it is set to the default value "1". For
|
||||
* more information about capacity weighting, see <a
|
||||
* href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/asg-instance-weighting.html">
|
||||
* Instance Weighting for Amazon EC2 Auto Scaling</a> in the Amazon EC2 Auto
|
||||
* Scaling User Guide.</p>
|
||||
*/
|
||||
inline const Aws::Vector<InstanceDefinition>& GetInstanceDefinitions() const{ return m_instanceDefinitions; }
|
||||
inline bool InstanceDefinitionsHasBeenSet() const { return m_instanceDefinitionsHasBeenSet; }
|
||||
inline void SetInstanceDefinitions(const Aws::Vector<InstanceDefinition>& value) { m_instanceDefinitionsHasBeenSet = true; m_instanceDefinitions = value; }
|
||||
inline void SetInstanceDefinitions(Aws::Vector<InstanceDefinition>&& value) { m_instanceDefinitionsHasBeenSet = true; m_instanceDefinitions = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithInstanceDefinitions(const Aws::Vector<InstanceDefinition>& value) { SetInstanceDefinitions(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithInstanceDefinitions(Aws::Vector<InstanceDefinition>&& value) { SetInstanceDefinitions(std::move(value)); return *this;}
|
||||
inline CreateGameServerGroupRequest& AddInstanceDefinitions(const InstanceDefinition& value) { m_instanceDefinitionsHasBeenSet = true; m_instanceDefinitions.push_back(value); return *this; }
|
||||
inline CreateGameServerGroupRequest& AddInstanceDefinitions(InstanceDefinition&& value) { m_instanceDefinitionsHasBeenSet = true; m_instanceDefinitions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Configuration settings to define a scaling policy for the Auto Scaling group
|
||||
* that is optimized for game hosting. The scaling policy uses the metric
|
||||
* <code>"PercentUtilizedGameServers"</code> to maintain a buffer of idle game
|
||||
* servers that can immediately accommodate new games and players. After the Auto
|
||||
* Scaling group is created, update this value directly in the Auto Scaling group
|
||||
* using the Amazon Web Services console or APIs.</p>
|
||||
*/
|
||||
inline const GameServerGroupAutoScalingPolicy& GetAutoScalingPolicy() const{ return m_autoScalingPolicy; }
|
||||
inline bool AutoScalingPolicyHasBeenSet() const { return m_autoScalingPolicyHasBeenSet; }
|
||||
inline void SetAutoScalingPolicy(const GameServerGroupAutoScalingPolicy& value) { m_autoScalingPolicyHasBeenSet = true; m_autoScalingPolicy = value; }
|
||||
inline void SetAutoScalingPolicy(GameServerGroupAutoScalingPolicy&& value) { m_autoScalingPolicyHasBeenSet = true; m_autoScalingPolicy = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithAutoScalingPolicy(const GameServerGroupAutoScalingPolicy& value) { SetAutoScalingPolicy(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithAutoScalingPolicy(GameServerGroupAutoScalingPolicy&& value) { SetAutoScalingPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates how Amazon GameLift FleetIQ balances the use of Spot Instances and
|
||||
* On-Demand Instances in the game server group. Method options include the
|
||||
* following:</p> <ul> <li> <p> <code>SPOT_ONLY</code> - Only Spot Instances are
|
||||
* used in the game server group. If Spot Instances are unavailable or not viable
|
||||
* for game hosting, the game server group provides no hosting capacity until Spot
|
||||
* Instances can again be used. Until then, no new instances are started, and the
|
||||
* existing nonviable Spot Instances are terminated (after current gameplay ends)
|
||||
* and are not replaced.</p> </li> <li> <p> <code>SPOT_PREFERRED</code> - (default
|
||||
* value) Spot Instances are used whenever available in the game server group. If
|
||||
* Spot Instances are unavailable, the game server group continues to provide
|
||||
* hosting capacity by falling back to On-Demand Instances. Existing nonviable Spot
|
||||
* Instances are terminated (after current gameplay ends) and are replaced with new
|
||||
* On-Demand Instances.</p> </li> <li> <p> <code>ON_DEMAND_ONLY</code> - Only
|
||||
* On-Demand Instances are used in the game server group. No Spot Instances are
|
||||
* used, even when available, while this balancing strategy is in force.</p> </li>
|
||||
* </ul>
|
||||
*/
|
||||
inline const BalancingStrategy& GetBalancingStrategy() const{ return m_balancingStrategy; }
|
||||
inline bool BalancingStrategyHasBeenSet() const { return m_balancingStrategyHasBeenSet; }
|
||||
inline void SetBalancingStrategy(const BalancingStrategy& value) { m_balancingStrategyHasBeenSet = true; m_balancingStrategy = value; }
|
||||
inline void SetBalancingStrategy(BalancingStrategy&& value) { m_balancingStrategyHasBeenSet = true; m_balancingStrategy = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithBalancingStrategy(const BalancingStrategy& value) { SetBalancingStrategy(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithBalancingStrategy(BalancingStrategy&& value) { SetBalancingStrategy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A flag that indicates whether instances in the game server group are
|
||||
* protected from early termination. Unprotected instances that have active game
|
||||
* servers running might be terminated during a scale-down event, causing players
|
||||
* to be dropped from the game. Protected instances cannot be terminated while
|
||||
* there are active game servers running except in the event of a forced game
|
||||
* server group deletion (see ). An exception to this is with Spot Instances, which
|
||||
* can be terminated by Amazon Web Services regardless of protection status. This
|
||||
* property is set to <code>NO_PROTECTION</code> by default.</p>
|
||||
*/
|
||||
inline const GameServerProtectionPolicy& GetGameServerProtectionPolicy() const{ return m_gameServerProtectionPolicy; }
|
||||
inline bool GameServerProtectionPolicyHasBeenSet() const { return m_gameServerProtectionPolicyHasBeenSet; }
|
||||
inline void SetGameServerProtectionPolicy(const GameServerProtectionPolicy& value) { m_gameServerProtectionPolicyHasBeenSet = true; m_gameServerProtectionPolicy = value; }
|
||||
inline void SetGameServerProtectionPolicy(GameServerProtectionPolicy&& value) { m_gameServerProtectionPolicyHasBeenSet = true; m_gameServerProtectionPolicy = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithGameServerProtectionPolicy(const GameServerProtectionPolicy& value) { SetGameServerProtectionPolicy(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithGameServerProtectionPolicy(GameServerProtectionPolicy&& value) { SetGameServerProtectionPolicy(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of virtual private cloud (VPC) subnets to use with instances in the
|
||||
* game server group. By default, all Amazon GameLift FleetIQ-supported
|
||||
* Availability Zones are used. You can use this parameter to specify VPCs that
|
||||
* you've set up. This property cannot be updated after the game server group is
|
||||
* created, and the corresponding Auto Scaling group will always use the property
|
||||
* value that is set with this request, even if the Auto Scaling group is updated
|
||||
* directly.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetVpcSubnets() const{ return m_vpcSubnets; }
|
||||
inline bool VpcSubnetsHasBeenSet() const { return m_vpcSubnetsHasBeenSet; }
|
||||
inline void SetVpcSubnets(const Aws::Vector<Aws::String>& value) { m_vpcSubnetsHasBeenSet = true; m_vpcSubnets = value; }
|
||||
inline void SetVpcSubnets(Aws::Vector<Aws::String>&& value) { m_vpcSubnetsHasBeenSet = true; m_vpcSubnets = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithVpcSubnets(const Aws::Vector<Aws::String>& value) { SetVpcSubnets(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithVpcSubnets(Aws::Vector<Aws::String>&& value) { SetVpcSubnets(std::move(value)); return *this;}
|
||||
inline CreateGameServerGroupRequest& AddVpcSubnets(const Aws::String& value) { m_vpcSubnetsHasBeenSet = true; m_vpcSubnets.push_back(value); return *this; }
|
||||
inline CreateGameServerGroupRequest& AddVpcSubnets(Aws::String&& value) { m_vpcSubnetsHasBeenSet = true; m_vpcSubnets.push_back(std::move(value)); return *this; }
|
||||
inline CreateGameServerGroupRequest& AddVpcSubnets(const char* value) { m_vpcSubnetsHasBeenSet = true; m_vpcSubnets.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new game server group resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources is
|
||||
* useful for resource management, access management, and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateGameServerGroupRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateGameServerGroupRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateGameServerGroupRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateGameServerGroupRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_gameServerGroupName;
|
||||
bool m_gameServerGroupNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_roleArn;
|
||||
bool m_roleArnHasBeenSet = false;
|
||||
|
||||
int m_minSize;
|
||||
bool m_minSizeHasBeenSet = false;
|
||||
|
||||
int m_maxSize;
|
||||
bool m_maxSizeHasBeenSet = false;
|
||||
|
||||
LaunchTemplateSpecification m_launchTemplate;
|
||||
bool m_launchTemplateHasBeenSet = false;
|
||||
|
||||
Aws::Vector<InstanceDefinition> m_instanceDefinitions;
|
||||
bool m_instanceDefinitionsHasBeenSet = false;
|
||||
|
||||
GameServerGroupAutoScalingPolicy m_autoScalingPolicy;
|
||||
bool m_autoScalingPolicyHasBeenSet = false;
|
||||
|
||||
BalancingStrategy m_balancingStrategy;
|
||||
bool m_balancingStrategyHasBeenSet = false;
|
||||
|
||||
GameServerProtectionPolicy m_gameServerProtectionPolicy;
|
||||
bool m_gameServerProtectionPolicyHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_vpcSubnets;
|
||||
bool m_vpcSubnetsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/GameServerGroup.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateGameServerGroupResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateGameServerGroupResult();
|
||||
AWS_GAMELIFT_API CreateGameServerGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateGameServerGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created game server group object, including the new ARN value for
|
||||
* the Amazon GameLift FleetIQ game server group and the object's status. The
|
||||
* Amazon EC2 Auto Scaling group ARN is initially null, since the group has not yet
|
||||
* been created. This value is added once the game server group status reaches
|
||||
* <code>ACTIVE</code>. </p>
|
||||
*/
|
||||
inline const GameServerGroup& GetGameServerGroup() const{ return m_gameServerGroup; }
|
||||
inline void SetGameServerGroup(const GameServerGroup& value) { m_gameServerGroup = value; }
|
||||
inline void SetGameServerGroup(GameServerGroup&& value) { m_gameServerGroup = std::move(value); }
|
||||
inline CreateGameServerGroupResult& WithGameServerGroup(const GameServerGroup& value) { SetGameServerGroup(value); return *this;}
|
||||
inline CreateGameServerGroupResult& WithGameServerGroup(GameServerGroup&& value) { SetGameServerGroup(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateGameServerGroupResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateGameServerGroupResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateGameServerGroupResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
GameServerGroup m_gameServerGroup;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,217 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/FilterConfiguration.h>
|
||||
#include <aws/gamelift/model/PriorityConfiguration.h>
|
||||
#include <aws/gamelift/model/PlayerLatencyPolicy.h>
|
||||
#include <aws/gamelift/model/GameSessionQueueDestination.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateGameSessionQueueRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateGameSessionQueueRequest();
|
||||
|
||||
// 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 "CreateGameSessionQueue"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with game session queue. Queue names
|
||||
* must be unique within each Region.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateGameSessionQueueRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum time, in seconds, that a new game session placement request
|
||||
* remains in the queue. When a request exceeds this time, the game session
|
||||
* placement changes to a <code>TIMED_OUT</code> status.</p>
|
||||
*/
|
||||
inline int GetTimeoutInSeconds() const{ return m_timeoutInSeconds; }
|
||||
inline bool TimeoutInSecondsHasBeenSet() const { return m_timeoutInSecondsHasBeenSet; }
|
||||
inline void SetTimeoutInSeconds(int value) { m_timeoutInSecondsHasBeenSet = true; m_timeoutInSeconds = value; }
|
||||
inline CreateGameSessionQueueRequest& WithTimeoutInSeconds(int value) { SetTimeoutInSeconds(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of policies that enforce a sliding cap on player latency when
|
||||
* processing game sessions placement requests. Use multiple policies to gradually
|
||||
* relax the cap over time if Amazon GameLift can't make a placement. Policies are
|
||||
* evaluated in order starting with the lowest maximum latency value.</p>
|
||||
*/
|
||||
inline const Aws::Vector<PlayerLatencyPolicy>& GetPlayerLatencyPolicies() const{ return m_playerLatencyPolicies; }
|
||||
inline bool PlayerLatencyPoliciesHasBeenSet() const { return m_playerLatencyPoliciesHasBeenSet; }
|
||||
inline void SetPlayerLatencyPolicies(const Aws::Vector<PlayerLatencyPolicy>& value) { m_playerLatencyPoliciesHasBeenSet = true; m_playerLatencyPolicies = value; }
|
||||
inline void SetPlayerLatencyPolicies(Aws::Vector<PlayerLatencyPolicy>&& value) { m_playerLatencyPoliciesHasBeenSet = true; m_playerLatencyPolicies = std::move(value); }
|
||||
inline CreateGameSessionQueueRequest& WithPlayerLatencyPolicies(const Aws::Vector<PlayerLatencyPolicy>& value) { SetPlayerLatencyPolicies(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithPlayerLatencyPolicies(Aws::Vector<PlayerLatencyPolicy>&& value) { SetPlayerLatencyPolicies(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueRequest& AddPlayerLatencyPolicies(const PlayerLatencyPolicy& value) { m_playerLatencyPoliciesHasBeenSet = true; m_playerLatencyPolicies.push_back(value); return *this; }
|
||||
inline CreateGameSessionQueueRequest& AddPlayerLatencyPolicies(PlayerLatencyPolicy&& value) { m_playerLatencyPoliciesHasBeenSet = true; m_playerLatencyPolicies.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of fleets and/or fleet aliases that can be used to fulfill game
|
||||
* session placement requests in the queue. Destinations are identified by either a
|
||||
* fleet ARN or a fleet alias ARN, and are listed in order of placement
|
||||
* preference.</p>
|
||||
*/
|
||||
inline const Aws::Vector<GameSessionQueueDestination>& GetDestinations() const{ return m_destinations; }
|
||||
inline bool DestinationsHasBeenSet() const { return m_destinationsHasBeenSet; }
|
||||
inline void SetDestinations(const Aws::Vector<GameSessionQueueDestination>& value) { m_destinationsHasBeenSet = true; m_destinations = value; }
|
||||
inline void SetDestinations(Aws::Vector<GameSessionQueueDestination>&& value) { m_destinationsHasBeenSet = true; m_destinations = std::move(value); }
|
||||
inline CreateGameSessionQueueRequest& WithDestinations(const Aws::Vector<GameSessionQueueDestination>& value) { SetDestinations(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithDestinations(Aws::Vector<GameSessionQueueDestination>&& value) { SetDestinations(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueRequest& AddDestinations(const GameSessionQueueDestination& value) { m_destinationsHasBeenSet = true; m_destinations.push_back(value); return *this; }
|
||||
inline CreateGameSessionQueueRequest& AddDestinations(GameSessionQueueDestination&& value) { m_destinationsHasBeenSet = true; m_destinations.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of locations where a queue is allowed to place new game sessions.
|
||||
* Locations are specified in the form of Amazon Web Services Region codes, such as
|
||||
* <code>us-west-2</code>. If this parameter is not set, game sessions can be
|
||||
* placed in any queue location. </p>
|
||||
*/
|
||||
inline const FilterConfiguration& GetFilterConfiguration() const{ return m_filterConfiguration; }
|
||||
inline bool FilterConfigurationHasBeenSet() const { return m_filterConfigurationHasBeenSet; }
|
||||
inline void SetFilterConfiguration(const FilterConfiguration& value) { m_filterConfigurationHasBeenSet = true; m_filterConfiguration = value; }
|
||||
inline void SetFilterConfiguration(FilterConfiguration&& value) { m_filterConfigurationHasBeenSet = true; m_filterConfiguration = std::move(value); }
|
||||
inline CreateGameSessionQueueRequest& WithFilterConfiguration(const FilterConfiguration& value) { SetFilterConfiguration(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithFilterConfiguration(FilterConfiguration&& value) { SetFilterConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Custom settings to use when prioritizing destinations and locations for game
|
||||
* session placements. This configuration replaces the FleetIQ default
|
||||
* prioritization process. Priority types that are not explicitly named will be
|
||||
* automatically applied at the end of the prioritization process. </p>
|
||||
*/
|
||||
inline const PriorityConfiguration& GetPriorityConfiguration() const{ return m_priorityConfiguration; }
|
||||
inline bool PriorityConfigurationHasBeenSet() const { return m_priorityConfigurationHasBeenSet; }
|
||||
inline void SetPriorityConfiguration(const PriorityConfiguration& value) { m_priorityConfigurationHasBeenSet = true; m_priorityConfiguration = value; }
|
||||
inline void SetPriorityConfiguration(PriorityConfiguration&& value) { m_priorityConfigurationHasBeenSet = true; m_priorityConfiguration = std::move(value); }
|
||||
inline CreateGameSessionQueueRequest& WithPriorityConfiguration(const PriorityConfiguration& value) { SetPriorityConfiguration(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithPriorityConfiguration(PriorityConfiguration&& value) { SetPriorityConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Information to be added to all events that are related to this game session
|
||||
* queue.</p>
|
||||
*/
|
||||
inline const Aws::String& GetCustomEventData() const{ return m_customEventData; }
|
||||
inline bool CustomEventDataHasBeenSet() const { return m_customEventDataHasBeenSet; }
|
||||
inline void SetCustomEventData(const Aws::String& value) { m_customEventDataHasBeenSet = true; m_customEventData = value; }
|
||||
inline void SetCustomEventData(Aws::String&& value) { m_customEventDataHasBeenSet = true; m_customEventData = std::move(value); }
|
||||
inline void SetCustomEventData(const char* value) { m_customEventDataHasBeenSet = true; m_customEventData.assign(value); }
|
||||
inline CreateGameSessionQueueRequest& WithCustomEventData(const Aws::String& value) { SetCustomEventData(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithCustomEventData(Aws::String&& value) { SetCustomEventData(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithCustomEventData(const char* value) { SetCustomEventData(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An SNS topic ARN that is set up to receive game session placement
|
||||
* notifications. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/queue-notification.html">
|
||||
* Setting up notifications for game session placement</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNotificationTarget() const{ return m_notificationTarget; }
|
||||
inline bool NotificationTargetHasBeenSet() const { return m_notificationTargetHasBeenSet; }
|
||||
inline void SetNotificationTarget(const Aws::String& value) { m_notificationTargetHasBeenSet = true; m_notificationTarget = value; }
|
||||
inline void SetNotificationTarget(Aws::String&& value) { m_notificationTargetHasBeenSet = true; m_notificationTarget = std::move(value); }
|
||||
inline void SetNotificationTarget(const char* value) { m_notificationTargetHasBeenSet = true; m_notificationTarget.assign(value); }
|
||||
inline CreateGameSessionQueueRequest& WithNotificationTarget(const Aws::String& value) { SetNotificationTarget(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithNotificationTarget(Aws::String&& value) { SetNotificationTarget(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithNotificationTarget(const char* value) { SetNotificationTarget(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new game session queue resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateGameSessionQueueRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateGameSessionQueueRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateGameSessionQueueRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
int m_timeoutInSeconds;
|
||||
bool m_timeoutInSecondsHasBeenSet = false;
|
||||
|
||||
Aws::Vector<PlayerLatencyPolicy> m_playerLatencyPolicies;
|
||||
bool m_playerLatencyPoliciesHasBeenSet = false;
|
||||
|
||||
Aws::Vector<GameSessionQueueDestination> m_destinations;
|
||||
bool m_destinationsHasBeenSet = false;
|
||||
|
||||
FilterConfiguration m_filterConfiguration;
|
||||
bool m_filterConfigurationHasBeenSet = false;
|
||||
|
||||
PriorityConfiguration m_priorityConfiguration;
|
||||
bool m_priorityConfigurationHasBeenSet = false;
|
||||
|
||||
Aws::String m_customEventData;
|
||||
bool m_customEventDataHasBeenSet = false;
|
||||
|
||||
Aws::String m_notificationTarget;
|
||||
bool m_notificationTargetHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/GameSessionQueue.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateGameSessionQueueResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateGameSessionQueueResult();
|
||||
AWS_GAMELIFT_API CreateGameSessionQueueResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateGameSessionQueueResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An object that describes the newly created game session queue.</p>
|
||||
*/
|
||||
inline const GameSessionQueue& GetGameSessionQueue() const{ return m_gameSessionQueue; }
|
||||
inline void SetGameSessionQueue(const GameSessionQueue& value) { m_gameSessionQueue = value; }
|
||||
inline void SetGameSessionQueue(GameSessionQueue&& value) { m_gameSessionQueue = std::move(value); }
|
||||
inline CreateGameSessionQueueResult& WithGameSessionQueue(const GameSessionQueue& value) { SetGameSessionQueue(value); return *this;}
|
||||
inline CreateGameSessionQueueResult& WithGameSessionQueue(GameSessionQueue&& value) { SetGameSessionQueue(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateGameSessionQueueResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateGameSessionQueueResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateGameSessionQueueResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
GameSessionQueue m_gameSessionQueue;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,249 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/GameProperty.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateGameSessionRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateGameSessionRequest();
|
||||
|
||||
// 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 "CreateGameSession"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet to create a game session in. You can use
|
||||
* either the fleet ID or ARN value. Each request must reference either a fleet ID
|
||||
* or alias ID, but not both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline CreateGameSessionRequest& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the alias associated with the fleet to create a game
|
||||
* session in. You can use either the alias ID or ARN value. Each request must
|
||||
* reference either a fleet ID or alias ID, but not both.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAliasId() const{ return m_aliasId; }
|
||||
inline bool AliasIdHasBeenSet() const { return m_aliasIdHasBeenSet; }
|
||||
inline void SetAliasId(const Aws::String& value) { m_aliasIdHasBeenSet = true; m_aliasId = value; }
|
||||
inline void SetAliasId(Aws::String&& value) { m_aliasIdHasBeenSet = true; m_aliasId = std::move(value); }
|
||||
inline void SetAliasId(const char* value) { m_aliasIdHasBeenSet = true; m_aliasId.assign(value); }
|
||||
inline CreateGameSessionRequest& WithAliasId(const Aws::String& value) { SetAliasId(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithAliasId(Aws::String&& value) { SetAliasId(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithAliasId(const char* value) { SetAliasId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum number of players that can be connected simultaneously to the
|
||||
* game session.</p>
|
||||
*/
|
||||
inline int GetMaximumPlayerSessionCount() const{ return m_maximumPlayerSessionCount; }
|
||||
inline bool MaximumPlayerSessionCountHasBeenSet() const { return m_maximumPlayerSessionCountHasBeenSet; }
|
||||
inline void SetMaximumPlayerSessionCount(int value) { m_maximumPlayerSessionCountHasBeenSet = true; m_maximumPlayerSessionCount = value; }
|
||||
inline CreateGameSessionRequest& WithMaximumPlayerSessionCount(int value) { SetMaximumPlayerSessionCount(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with a game session. Session names do
|
||||
* not need to be unique.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateGameSessionRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of key-value pairs that can store custom data in a game session. For
|
||||
* example: <code>{"Key": "difficulty", "Value": "novice"}</code>. For an example,
|
||||
* see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-client-api.html#game-properties-create">Create
|
||||
* a game session with custom properties</a>. </p>
|
||||
*/
|
||||
inline const Aws::Vector<GameProperty>& GetGameProperties() const{ return m_gameProperties; }
|
||||
inline bool GamePropertiesHasBeenSet() const { return m_gamePropertiesHasBeenSet; }
|
||||
inline void SetGameProperties(const Aws::Vector<GameProperty>& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties = value; }
|
||||
inline void SetGameProperties(Aws::Vector<GameProperty>&& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties = std::move(value); }
|
||||
inline CreateGameSessionRequest& WithGameProperties(const Aws::Vector<GameProperty>& value) { SetGameProperties(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithGameProperties(Aws::Vector<GameProperty>&& value) { SetGameProperties(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& AddGameProperties(const GameProperty& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties.push_back(value); return *this; }
|
||||
inline CreateGameSessionRequest& AddGameProperties(GameProperty&& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a player or entity creating the game session. </p>
|
||||
* <p>If you add a resource creation limit policy to a fleet, the
|
||||
* <code>CreateGameSession</code> operation requires a <code>CreatorId</code>.
|
||||
* Amazon GameLift limits the number of game session creation requests with the
|
||||
* same <code>CreatorId</code> in a specified time period.</p> <p>If you your fleet
|
||||
* doesn't have a resource creation limit policy and you provide a
|
||||
* <code>CreatorId</code> in your <code>CreateGameSession</code> requests, Amazon
|
||||
* GameLift limits requests to one request per <code>CreatorId</code> per
|
||||
* second.</p> <p>To not limit <code>CreateGameSession</code> requests with the
|
||||
* same <code>CreatorId</code>, don't provide a <code>CreatorId</code> in your
|
||||
* <code>CreateGameSession</code> request.</p>
|
||||
*/
|
||||
inline const Aws::String& GetCreatorId() const{ return m_creatorId; }
|
||||
inline bool CreatorIdHasBeenSet() const { return m_creatorIdHasBeenSet; }
|
||||
inline void SetCreatorId(const Aws::String& value) { m_creatorIdHasBeenSet = true; m_creatorId = value; }
|
||||
inline void SetCreatorId(Aws::String&& value) { m_creatorIdHasBeenSet = true; m_creatorId = std::move(value); }
|
||||
inline void SetCreatorId(const char* value) { m_creatorIdHasBeenSet = true; m_creatorId.assign(value); }
|
||||
inline CreateGameSessionRequest& WithCreatorId(const Aws::String& value) { SetCreatorId(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithCreatorId(Aws::String&& value) { SetCreatorId(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithCreatorId(const char* value) { SetCreatorId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p> <i>This parameter is deprecated. Use <code>IdempotencyToken</code>
|
||||
* instead.</i> </p> <p>Custom string that uniquely identifies a request for a new
|
||||
* game session. Maximum token length is 48 characters. If provided, this string is
|
||||
* included in the new game session's ID.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameSessionId() const{ return m_gameSessionId; }
|
||||
inline bool GameSessionIdHasBeenSet() const { return m_gameSessionIdHasBeenSet; }
|
||||
inline void SetGameSessionId(const Aws::String& value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId = value; }
|
||||
inline void SetGameSessionId(Aws::String&& value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId = std::move(value); }
|
||||
inline void SetGameSessionId(const char* value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId.assign(value); }
|
||||
inline CreateGameSessionRequest& WithGameSessionId(const Aws::String& value) { SetGameSessionId(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithGameSessionId(Aws::String&& value) { SetGameSessionId(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithGameSessionId(const char* value) { SetGameSessionId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Custom string that uniquely identifies the new game session request. This is
|
||||
* useful for ensuring that game session requests with the same idempotency token
|
||||
* are processed only once. Subsequent requests with the same string return the
|
||||
* original <code>GameSession</code> object, with an updated status. Maximum token
|
||||
* length is 48 characters. If provided, this string is included in the new game
|
||||
* session's ID. A game session ARN has the following format:
|
||||
* <code>arn:aws:gamelift:<region>::gamesession/<fleet ID>/<custom
|
||||
* ID string or idempotency token></code>. Idempotency tokens remain in use for
|
||||
* 30 days after a game session has ended; game session objects are retained for
|
||||
* this time period and then deleted.</p>
|
||||
*/
|
||||
inline const Aws::String& GetIdempotencyToken() const{ return m_idempotencyToken; }
|
||||
inline bool IdempotencyTokenHasBeenSet() const { return m_idempotencyTokenHasBeenSet; }
|
||||
inline void SetIdempotencyToken(const Aws::String& value) { m_idempotencyTokenHasBeenSet = true; m_idempotencyToken = value; }
|
||||
inline void SetIdempotencyToken(Aws::String&& value) { m_idempotencyTokenHasBeenSet = true; m_idempotencyToken = std::move(value); }
|
||||
inline void SetIdempotencyToken(const char* value) { m_idempotencyTokenHasBeenSet = true; m_idempotencyToken.assign(value); }
|
||||
inline CreateGameSessionRequest& WithIdempotencyToken(const Aws::String& value) { SetIdempotencyToken(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithIdempotencyToken(Aws::String&& value) { SetIdempotencyToken(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithIdempotencyToken(const char* value) { SetIdempotencyToken(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of custom game session properties, formatted as a single string value.
|
||||
* This data is passed to a game server process with a request to start a new game
|
||||
* session. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession">Start
|
||||
* a game session</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameSessionData() const{ return m_gameSessionData; }
|
||||
inline bool GameSessionDataHasBeenSet() const { return m_gameSessionDataHasBeenSet; }
|
||||
inline void SetGameSessionData(const Aws::String& value) { m_gameSessionDataHasBeenSet = true; m_gameSessionData = value; }
|
||||
inline void SetGameSessionData(Aws::String&& value) { m_gameSessionDataHasBeenSet = true; m_gameSessionData = std::move(value); }
|
||||
inline void SetGameSessionData(const char* value) { m_gameSessionDataHasBeenSet = true; m_gameSessionData.assign(value); }
|
||||
inline CreateGameSessionRequest& WithGameSessionData(const Aws::String& value) { SetGameSessionData(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithGameSessionData(Aws::String&& value) { SetGameSessionData(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithGameSessionData(const char* value) { SetGameSessionData(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A fleet's remote location to place the new game session in. If this parameter
|
||||
* is not set, the new game session is placed in the fleet's home Region. Specify a
|
||||
* remote location with an Amazon Web Services Region code such as
|
||||
* <code>us-west-2</code>. When using an Anywhere fleet, this parameter is required
|
||||
* and must be set to the Anywhere fleet's custom location.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLocation() const{ return m_location; }
|
||||
inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
|
||||
inline void SetLocation(const Aws::String& value) { m_locationHasBeenSet = true; m_location = value; }
|
||||
inline void SetLocation(Aws::String&& value) { m_locationHasBeenSet = true; m_location = std::move(value); }
|
||||
inline void SetLocation(const char* value) { m_locationHasBeenSet = true; m_location.assign(value); }
|
||||
inline CreateGameSessionRequest& WithLocation(const Aws::String& value) { SetLocation(value); return *this;}
|
||||
inline CreateGameSessionRequest& WithLocation(Aws::String&& value) { SetLocation(std::move(value)); return *this;}
|
||||
inline CreateGameSessionRequest& WithLocation(const char* value) { SetLocation(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_aliasId;
|
||||
bool m_aliasIdHasBeenSet = false;
|
||||
|
||||
int m_maximumPlayerSessionCount;
|
||||
bool m_maximumPlayerSessionCountHasBeenSet = false;
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<GameProperty> m_gameProperties;
|
||||
bool m_gamePropertiesHasBeenSet = false;
|
||||
|
||||
Aws::String m_creatorId;
|
||||
bool m_creatorIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameSessionId;
|
||||
bool m_gameSessionIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_idempotencyToken;
|
||||
bool m_idempotencyTokenHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameSessionData;
|
||||
bool m_gameSessionDataHasBeenSet = false;
|
||||
|
||||
Aws::String m_location;
|
||||
bool m_locationHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/GameSession.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateGameSessionResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateGameSessionResult();
|
||||
AWS_GAMELIFT_API CreateGameSessionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateGameSessionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Object that describes the newly created game session record.</p>
|
||||
*/
|
||||
inline const GameSession& GetGameSession() const{ return m_gameSession; }
|
||||
inline void SetGameSession(const GameSession& value) { m_gameSession = value; }
|
||||
inline void SetGameSession(GameSession&& value) { m_gameSession = std::move(value); }
|
||||
inline CreateGameSessionResult& WithGameSession(const GameSession& value) { SetGameSession(value); return *this;}
|
||||
inline CreateGameSessionResult& WithGameSession(GameSession&& value) { SetGameSession(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateGameSessionResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateGameSessionResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateGameSessionResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
GameSession m_gameSession;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateLocationRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateLocationRequest();
|
||||
|
||||
// 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 "CreateLocation"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive name for the custom location.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLocationName() const{ return m_locationName; }
|
||||
inline bool LocationNameHasBeenSet() const { return m_locationNameHasBeenSet; }
|
||||
inline void SetLocationName(const Aws::String& value) { m_locationNameHasBeenSet = true; m_locationName = value; }
|
||||
inline void SetLocationName(Aws::String&& value) { m_locationNameHasBeenSet = true; m_locationName = std::move(value); }
|
||||
inline void SetLocationName(const char* value) { m_locationNameHasBeenSet = true; m_locationName.assign(value); }
|
||||
inline CreateLocationRequest& WithLocationName(const Aws::String& value) { SetLocationName(value); return *this;}
|
||||
inline CreateLocationRequest& WithLocationName(Aws::String&& value) { SetLocationName(std::move(value)); return *this;}
|
||||
inline CreateLocationRequest& WithLocationName(const char* value) { SetLocationName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new resource. Tags are developer-defined
|
||||
* key-value pairs. Tagging Amazon Web Services resources are useful for resource
|
||||
* management, access management, and cost allocation. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Rareference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateLocationRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateLocationRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateLocationRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateLocationRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_locationName;
|
||||
bool m_locationNameHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/LocationModel.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateLocationResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateLocationResult();
|
||||
AWS_GAMELIFT_API CreateLocationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateLocationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The details of the custom location you created.</p>
|
||||
*/
|
||||
inline const LocationModel& GetLocation() const{ return m_location; }
|
||||
inline void SetLocation(const LocationModel& value) { m_location = value; }
|
||||
inline void SetLocation(LocationModel&& value) { m_location = std::move(value); }
|
||||
inline CreateLocationResult& WithLocation(const LocationModel& value) { SetLocation(value); return *this;}
|
||||
inline CreateLocationResult& WithLocation(LocationModel&& value) { SetLocation(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateLocationResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateLocationResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateLocationResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
LocationModel m_location;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,339 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/BackfillMode.h>
|
||||
#include <aws/gamelift/model/FlexMatchMode.h>
|
||||
#include <aws/gamelift/model/GameProperty.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateMatchmakingConfigurationRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateMatchmakingConfigurationRequest();
|
||||
|
||||
// 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 "CreateMatchmakingConfiguration"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the matchmaking configuration. This name is used to
|
||||
* identify the configuration associated with a matchmaking request or ticket.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A human-readable description of the matchmaking configuration. </p>
|
||||
*/
|
||||
inline const Aws::String& GetDescription() const{ return m_description; }
|
||||
inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
|
||||
inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
|
||||
inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
|
||||
inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithDescription(const char* value) { SetDescription(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to a Amazon GameLift game session queue resource and uniquely
|
||||
* identifies it. ARNs are unique across all Regions. Format is
|
||||
* <code>arn:aws:gamelift:<region>::gamesessionqueue/<queue
|
||||
* name></code>. Queues can be located in any Region. Queues are used to start
|
||||
* new Amazon GameLift-hosted game sessions for matches that are created with this
|
||||
* matchmaking configuration. If <code>FlexMatchMode</code> is set to
|
||||
* <code>STANDALONE</code>, do not set this parameter. </p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetGameSessionQueueArns() const{ return m_gameSessionQueueArns; }
|
||||
inline bool GameSessionQueueArnsHasBeenSet() const { return m_gameSessionQueueArnsHasBeenSet; }
|
||||
inline void SetGameSessionQueueArns(const Aws::Vector<Aws::String>& value) { m_gameSessionQueueArnsHasBeenSet = true; m_gameSessionQueueArns = value; }
|
||||
inline void SetGameSessionQueueArns(Aws::Vector<Aws::String>&& value) { m_gameSessionQueueArnsHasBeenSet = true; m_gameSessionQueueArns = std::move(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameSessionQueueArns(const Aws::Vector<Aws::String>& value) { SetGameSessionQueueArns(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameSessionQueueArns(Aws::Vector<Aws::String>&& value) { SetGameSessionQueueArns(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& AddGameSessionQueueArns(const Aws::String& value) { m_gameSessionQueueArnsHasBeenSet = true; m_gameSessionQueueArns.push_back(value); return *this; }
|
||||
inline CreateMatchmakingConfigurationRequest& AddGameSessionQueueArns(Aws::String&& value) { m_gameSessionQueueArnsHasBeenSet = true; m_gameSessionQueueArns.push_back(std::move(value)); return *this; }
|
||||
inline CreateMatchmakingConfigurationRequest& AddGameSessionQueueArns(const char* value) { m_gameSessionQueueArnsHasBeenSet = true; m_gameSessionQueueArns.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The maximum duration, in seconds, that a matchmaking ticket can remain in
|
||||
* process before timing out. Requests that fail due to timing out can be
|
||||
* resubmitted as needed.</p>
|
||||
*/
|
||||
inline int GetRequestTimeoutSeconds() const{ return m_requestTimeoutSeconds; }
|
||||
inline bool RequestTimeoutSecondsHasBeenSet() const { return m_requestTimeoutSecondsHasBeenSet; }
|
||||
inline void SetRequestTimeoutSeconds(int value) { m_requestTimeoutSecondsHasBeenSet = true; m_requestTimeoutSeconds = value; }
|
||||
inline CreateMatchmakingConfigurationRequest& WithRequestTimeoutSeconds(int value) { SetRequestTimeoutSeconds(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The length of time (in seconds) to wait for players to accept a proposed
|
||||
* match, if acceptance is required. </p>
|
||||
*/
|
||||
inline int GetAcceptanceTimeoutSeconds() const{ return m_acceptanceTimeoutSeconds; }
|
||||
inline bool AcceptanceTimeoutSecondsHasBeenSet() const { return m_acceptanceTimeoutSecondsHasBeenSet; }
|
||||
inline void SetAcceptanceTimeoutSeconds(int value) { m_acceptanceTimeoutSecondsHasBeenSet = true; m_acceptanceTimeoutSeconds = value; }
|
||||
inline CreateMatchmakingConfigurationRequest& WithAcceptanceTimeoutSeconds(int value) { SetAcceptanceTimeoutSeconds(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A flag that determines whether a match that was created with this
|
||||
* configuration must be accepted by the matched players. To require acceptance,
|
||||
* set to <code>TRUE</code>. With this option enabled, matchmaking tickets use the
|
||||
* status <code>REQUIRES_ACCEPTANCE</code> to indicate when a completed potential
|
||||
* match is waiting for player acceptance. </p>
|
||||
*/
|
||||
inline bool GetAcceptanceRequired() const{ return m_acceptanceRequired; }
|
||||
inline bool AcceptanceRequiredHasBeenSet() const { return m_acceptanceRequiredHasBeenSet; }
|
||||
inline void SetAcceptanceRequired(bool value) { m_acceptanceRequiredHasBeenSet = true; m_acceptanceRequired = value; }
|
||||
inline CreateMatchmakingConfigurationRequest& WithAcceptanceRequired(bool value) { SetAcceptanceRequired(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the matchmaking rule set to use with this
|
||||
* configuration. You can use either the rule set name or ARN value. A matchmaking
|
||||
* configuration can only use rule sets that are defined in the same Region.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRuleSetName() const{ return m_ruleSetName; }
|
||||
inline bool RuleSetNameHasBeenSet() const { return m_ruleSetNameHasBeenSet; }
|
||||
inline void SetRuleSetName(const Aws::String& value) { m_ruleSetNameHasBeenSet = true; m_ruleSetName = value; }
|
||||
inline void SetRuleSetName(Aws::String&& value) { m_ruleSetNameHasBeenSet = true; m_ruleSetName = std::move(value); }
|
||||
inline void SetRuleSetName(const char* value) { m_ruleSetNameHasBeenSet = true; m_ruleSetName.assign(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithRuleSetName(const Aws::String& value) { SetRuleSetName(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithRuleSetName(Aws::String&& value) { SetRuleSetName(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithRuleSetName(const char* value) { SetRuleSetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An SNS topic ARN that is set up to receive matchmaking notifications. See <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html">
|
||||
* Setting up notifications for matchmaking</a> for more information.</p>
|
||||
*/
|
||||
inline const Aws::String& GetNotificationTarget() const{ return m_notificationTarget; }
|
||||
inline bool NotificationTargetHasBeenSet() const { return m_notificationTargetHasBeenSet; }
|
||||
inline void SetNotificationTarget(const Aws::String& value) { m_notificationTargetHasBeenSet = true; m_notificationTarget = value; }
|
||||
inline void SetNotificationTarget(Aws::String&& value) { m_notificationTargetHasBeenSet = true; m_notificationTarget = std::move(value); }
|
||||
inline void SetNotificationTarget(const char* value) { m_notificationTargetHasBeenSet = true; m_notificationTarget.assign(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithNotificationTarget(const Aws::String& value) { SetNotificationTarget(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithNotificationTarget(Aws::String&& value) { SetNotificationTarget(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithNotificationTarget(const char* value) { SetNotificationTarget(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of player slots in a match to keep open for future players. For
|
||||
* example, if the configuration's rule set specifies a match for a single
|
||||
* 12-person team, and the additional player count is set to 2, only 10 players are
|
||||
* selected for the match. This parameter is not used if <code>FlexMatchMode</code>
|
||||
* is set to <code>STANDALONE</code>.</p>
|
||||
*/
|
||||
inline int GetAdditionalPlayerCount() const{ return m_additionalPlayerCount; }
|
||||
inline bool AdditionalPlayerCountHasBeenSet() const { return m_additionalPlayerCountHasBeenSet; }
|
||||
inline void SetAdditionalPlayerCount(int value) { m_additionalPlayerCountHasBeenSet = true; m_additionalPlayerCount = value; }
|
||||
inline CreateMatchmakingConfigurationRequest& WithAdditionalPlayerCount(int value) { SetAdditionalPlayerCount(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Information to be added to all events related to this matchmaking
|
||||
* configuration. </p>
|
||||
*/
|
||||
inline const Aws::String& GetCustomEventData() const{ return m_customEventData; }
|
||||
inline bool CustomEventDataHasBeenSet() const { return m_customEventDataHasBeenSet; }
|
||||
inline void SetCustomEventData(const Aws::String& value) { m_customEventDataHasBeenSet = true; m_customEventData = value; }
|
||||
inline void SetCustomEventData(Aws::String&& value) { m_customEventDataHasBeenSet = true; m_customEventData = std::move(value); }
|
||||
inline void SetCustomEventData(const char* value) { m_customEventDataHasBeenSet = true; m_customEventData.assign(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithCustomEventData(const Aws::String& value) { SetCustomEventData(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithCustomEventData(Aws::String&& value) { SetCustomEventData(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithCustomEventData(const char* value) { SetCustomEventData(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of key-value pairs that can store custom data in a game session. For
|
||||
* example: <code>{"Key": "difficulty", "Value": "novice"}</code>. This information
|
||||
* is added to the new <code>GameSession</code> object that is created for a
|
||||
* successful match. This parameter is not used if <code>FlexMatchMode</code> is
|
||||
* set to <code>STANDALONE</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<GameProperty>& GetGameProperties() const{ return m_gameProperties; }
|
||||
inline bool GamePropertiesHasBeenSet() const { return m_gamePropertiesHasBeenSet; }
|
||||
inline void SetGameProperties(const Aws::Vector<GameProperty>& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties = value; }
|
||||
inline void SetGameProperties(Aws::Vector<GameProperty>&& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties = std::move(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameProperties(const Aws::Vector<GameProperty>& value) { SetGameProperties(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameProperties(Aws::Vector<GameProperty>&& value) { SetGameProperties(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& AddGameProperties(const GameProperty& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties.push_back(value); return *this; }
|
||||
inline CreateMatchmakingConfigurationRequest& AddGameProperties(GameProperty&& value) { m_gamePropertiesHasBeenSet = true; m_gameProperties.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A set of custom game session properties, formatted as a single string value.
|
||||
* This data is passed to a game server process with a request to start a new game
|
||||
* session. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession">Start
|
||||
* a game session</a>. This information is added to the new
|
||||
* <code>GameSession</code> object that is created for a successful match. This
|
||||
* parameter is not used if <code>FlexMatchMode</code> is set to
|
||||
* <code>STANDALONE</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameSessionData() const{ return m_gameSessionData; }
|
||||
inline bool GameSessionDataHasBeenSet() const { return m_gameSessionDataHasBeenSet; }
|
||||
inline void SetGameSessionData(const Aws::String& value) { m_gameSessionDataHasBeenSet = true; m_gameSessionData = value; }
|
||||
inline void SetGameSessionData(Aws::String&& value) { m_gameSessionDataHasBeenSet = true; m_gameSessionData = std::move(value); }
|
||||
inline void SetGameSessionData(const char* value) { m_gameSessionDataHasBeenSet = true; m_gameSessionData.assign(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameSessionData(const Aws::String& value) { SetGameSessionData(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameSessionData(Aws::String&& value) { SetGameSessionData(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithGameSessionData(const char* value) { SetGameSessionData(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The method used to backfill game sessions that are created with this
|
||||
* matchmaking configuration. Specify <code>MANUAL</code> when your game manages
|
||||
* backfill requests manually or does not use the match backfill feature. Specify
|
||||
* <code>AUTOMATIC</code> to have Amazon GameLift create a backfill request
|
||||
* whenever a game session has one or more open slots. Learn more about manual and
|
||||
* automatic backfill in <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-backfill.html">
|
||||
* Backfill Existing Games with FlexMatch</a>. Automatic backfill is not available
|
||||
* when <code>FlexMatchMode</code> is set to <code>STANDALONE</code>.</p>
|
||||
*/
|
||||
inline const BackfillMode& GetBackfillMode() const{ return m_backfillMode; }
|
||||
inline bool BackfillModeHasBeenSet() const { return m_backfillModeHasBeenSet; }
|
||||
inline void SetBackfillMode(const BackfillMode& value) { m_backfillModeHasBeenSet = true; m_backfillMode = value; }
|
||||
inline void SetBackfillMode(BackfillMode&& value) { m_backfillModeHasBeenSet = true; m_backfillMode = std::move(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithBackfillMode(const BackfillMode& value) { SetBackfillMode(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithBackfillMode(BackfillMode&& value) { SetBackfillMode(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Indicates whether this matchmaking configuration is being used with Amazon
|
||||
* GameLift hosting or as a standalone matchmaking solution. </p> <ul> <li> <p>
|
||||
* <b>STANDALONE</b> - FlexMatch forms matches and returns match information,
|
||||
* including players and team assignments, in a <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-events.html#match-events-matchmakingsucceeded">
|
||||
* MatchmakingSucceeded</a> event.</p> </li> <li> <p> <b>WITH_QUEUE</b> - FlexMatch
|
||||
* forms matches and uses the specified Amazon GameLift queue to start a game
|
||||
* session for the match. </p> </li> </ul>
|
||||
*/
|
||||
inline const FlexMatchMode& GetFlexMatchMode() const{ return m_flexMatchMode; }
|
||||
inline bool FlexMatchModeHasBeenSet() const { return m_flexMatchModeHasBeenSet; }
|
||||
inline void SetFlexMatchMode(const FlexMatchMode& value) { m_flexMatchModeHasBeenSet = true; m_flexMatchMode = value; }
|
||||
inline void SetFlexMatchMode(FlexMatchMode&& value) { m_flexMatchModeHasBeenSet = true; m_flexMatchMode = std::move(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithFlexMatchMode(const FlexMatchMode& value) { SetFlexMatchMode(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithFlexMatchMode(FlexMatchMode&& value) { SetFlexMatchMode(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new matchmaking configuration resource.
|
||||
* Tags are developer-defined key-value pairs. Tagging Amazon Web Services
|
||||
* resources are useful for resource management, access management and cost
|
||||
* allocation. For more information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateMatchmakingConfigurationRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateMatchmakingConfigurationRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_description;
|
||||
bool m_descriptionHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_gameSessionQueueArns;
|
||||
bool m_gameSessionQueueArnsHasBeenSet = false;
|
||||
|
||||
int m_requestTimeoutSeconds;
|
||||
bool m_requestTimeoutSecondsHasBeenSet = false;
|
||||
|
||||
int m_acceptanceTimeoutSeconds;
|
||||
bool m_acceptanceTimeoutSecondsHasBeenSet = false;
|
||||
|
||||
bool m_acceptanceRequired;
|
||||
bool m_acceptanceRequiredHasBeenSet = false;
|
||||
|
||||
Aws::String m_ruleSetName;
|
||||
bool m_ruleSetNameHasBeenSet = false;
|
||||
|
||||
Aws::String m_notificationTarget;
|
||||
bool m_notificationTargetHasBeenSet = false;
|
||||
|
||||
int m_additionalPlayerCount;
|
||||
bool m_additionalPlayerCountHasBeenSet = false;
|
||||
|
||||
Aws::String m_customEventData;
|
||||
bool m_customEventDataHasBeenSet = false;
|
||||
|
||||
Aws::Vector<GameProperty> m_gameProperties;
|
||||
bool m_gamePropertiesHasBeenSet = false;
|
||||
|
||||
Aws::String m_gameSessionData;
|
||||
bool m_gameSessionDataHasBeenSet = false;
|
||||
|
||||
BackfillMode m_backfillMode;
|
||||
bool m_backfillModeHasBeenSet = false;
|
||||
|
||||
FlexMatchMode m_flexMatchMode;
|
||||
bool m_flexMatchModeHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/MatchmakingConfiguration.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateMatchmakingConfigurationResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateMatchmakingConfigurationResult();
|
||||
AWS_GAMELIFT_API CreateMatchmakingConfigurationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateMatchmakingConfigurationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Object that describes the newly created matchmaking configuration.</p>
|
||||
*/
|
||||
inline const MatchmakingConfiguration& GetConfiguration() const{ return m_configuration; }
|
||||
inline void SetConfiguration(const MatchmakingConfiguration& value) { m_configuration = value; }
|
||||
inline void SetConfiguration(MatchmakingConfiguration&& value) { m_configuration = std::move(value); }
|
||||
inline CreateMatchmakingConfigurationResult& WithConfiguration(const MatchmakingConfiguration& value) { SetConfiguration(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationResult& WithConfiguration(MatchmakingConfiguration&& value) { SetConfiguration(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateMatchmakingConfigurationResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateMatchmakingConfigurationResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingConfigurationResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
MatchmakingConfiguration m_configuration;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,103 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateMatchmakingRuleSetRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateMatchmakingRuleSetRequest();
|
||||
|
||||
// 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 "CreateMatchmakingRuleSet"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the matchmaking rule set. A matchmaking configuration
|
||||
* identifies the rule set it uses by this name value. Note that the rule set name
|
||||
* is different from the optional <code>name</code> field in the rule set body.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateMatchmakingRuleSetRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateMatchmakingRuleSetRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingRuleSetRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A collection of matchmaking rules, formatted as a JSON string. Comments are
|
||||
* not allowed in JSON, but most elements support a description field.</p>
|
||||
*/
|
||||
inline const Aws::String& GetRuleSetBody() const{ return m_ruleSetBody; }
|
||||
inline bool RuleSetBodyHasBeenSet() const { return m_ruleSetBodyHasBeenSet; }
|
||||
inline void SetRuleSetBody(const Aws::String& value) { m_ruleSetBodyHasBeenSet = true; m_ruleSetBody = value; }
|
||||
inline void SetRuleSetBody(Aws::String&& value) { m_ruleSetBodyHasBeenSet = true; m_ruleSetBody = std::move(value); }
|
||||
inline void SetRuleSetBody(const char* value) { m_ruleSetBodyHasBeenSet = true; m_ruleSetBody.assign(value); }
|
||||
inline CreateMatchmakingRuleSetRequest& WithRuleSetBody(const Aws::String& value) { SetRuleSetBody(value); return *this;}
|
||||
inline CreateMatchmakingRuleSetRequest& WithRuleSetBody(Aws::String&& value) { SetRuleSetBody(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingRuleSetRequest& WithRuleSetBody(const char* value) { SetRuleSetBody(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new matchmaking rule set resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateMatchmakingRuleSetRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateMatchmakingRuleSetRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingRuleSetRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateMatchmakingRuleSetRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_ruleSetBody;
|
||||
bool m_ruleSetBodyHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/MatchmakingRuleSet.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateMatchmakingRuleSetResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateMatchmakingRuleSetResult();
|
||||
AWS_GAMELIFT_API CreateMatchmakingRuleSetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateMatchmakingRuleSetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created matchmaking rule set.</p>
|
||||
*/
|
||||
inline const MatchmakingRuleSet& GetRuleSet() const{ return m_ruleSet; }
|
||||
inline void SetRuleSet(const MatchmakingRuleSet& value) { m_ruleSet = value; }
|
||||
inline void SetRuleSet(MatchmakingRuleSet&& value) { m_ruleSet = std::move(value); }
|
||||
inline CreateMatchmakingRuleSetResult& WithRuleSet(const MatchmakingRuleSet& value) { SetRuleSet(value); return *this;}
|
||||
inline CreateMatchmakingRuleSetResult& WithRuleSet(MatchmakingRuleSet&& value) { SetRuleSet(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateMatchmakingRuleSetResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateMatchmakingRuleSetResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateMatchmakingRuleSetResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
MatchmakingRuleSet m_ruleSet;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreatePlayerSessionRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreatePlayerSessionRequest();
|
||||
|
||||
// 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 "CreatePlayerSession"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the game session to add a player to.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameSessionId() const{ return m_gameSessionId; }
|
||||
inline bool GameSessionIdHasBeenSet() const { return m_gameSessionIdHasBeenSet; }
|
||||
inline void SetGameSessionId(const Aws::String& value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId = value; }
|
||||
inline void SetGameSessionId(Aws::String&& value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId = std::move(value); }
|
||||
inline void SetGameSessionId(const char* value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId.assign(value); }
|
||||
inline CreatePlayerSessionRequest& WithGameSessionId(const Aws::String& value) { SetGameSessionId(value); return *this;}
|
||||
inline CreatePlayerSessionRequest& WithGameSessionId(Aws::String&& value) { SetGameSessionId(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionRequest& WithGameSessionId(const char* value) { SetGameSessionId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a player. Player IDs are developer-defined.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPlayerId() const{ return m_playerId; }
|
||||
inline bool PlayerIdHasBeenSet() const { return m_playerIdHasBeenSet; }
|
||||
inline void SetPlayerId(const Aws::String& value) { m_playerIdHasBeenSet = true; m_playerId = value; }
|
||||
inline void SetPlayerId(Aws::String&& value) { m_playerIdHasBeenSet = true; m_playerId = std::move(value); }
|
||||
inline void SetPlayerId(const char* value) { m_playerIdHasBeenSet = true; m_playerId.assign(value); }
|
||||
inline CreatePlayerSessionRequest& WithPlayerId(const Aws::String& value) { SetPlayerId(value); return *this;}
|
||||
inline CreatePlayerSessionRequest& WithPlayerId(Aws::String&& value) { SetPlayerId(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionRequest& WithPlayerId(const char* value) { SetPlayerId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Developer-defined information related to a player. Amazon GameLift does not
|
||||
* use this data, so it can be formatted as needed for use in the game.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPlayerData() const{ return m_playerData; }
|
||||
inline bool PlayerDataHasBeenSet() const { return m_playerDataHasBeenSet; }
|
||||
inline void SetPlayerData(const Aws::String& value) { m_playerDataHasBeenSet = true; m_playerData = value; }
|
||||
inline void SetPlayerData(Aws::String&& value) { m_playerDataHasBeenSet = true; m_playerData = std::move(value); }
|
||||
inline void SetPlayerData(const char* value) { m_playerDataHasBeenSet = true; m_playerData.assign(value); }
|
||||
inline CreatePlayerSessionRequest& WithPlayerData(const Aws::String& value) { SetPlayerData(value); return *this;}
|
||||
inline CreatePlayerSessionRequest& WithPlayerData(Aws::String&& value) { SetPlayerData(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionRequest& WithPlayerData(const char* value) { SetPlayerData(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_gameSessionId;
|
||||
bool m_gameSessionIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_playerId;
|
||||
bool m_playerIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_playerData;
|
||||
bool m_playerDataHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/PlayerSession.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreatePlayerSessionResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreatePlayerSessionResult();
|
||||
AWS_GAMELIFT_API CreatePlayerSessionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreatePlayerSessionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Object that describes the newly created player session record.</p>
|
||||
*/
|
||||
inline const PlayerSession& GetPlayerSession() const{ return m_playerSession; }
|
||||
inline void SetPlayerSession(const PlayerSession& value) { m_playerSession = value; }
|
||||
inline void SetPlayerSession(PlayerSession&& value) { m_playerSession = std::move(value); }
|
||||
inline CreatePlayerSessionResult& WithPlayerSession(const PlayerSession& value) { SetPlayerSession(value); return *this;}
|
||||
inline CreatePlayerSessionResult& WithPlayerSession(PlayerSession&& value) { SetPlayerSession(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreatePlayerSessionResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreatePlayerSessionResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
PlayerSession m_playerSession;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,104 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSMap.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreatePlayerSessionsRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreatePlayerSessionsRequest();
|
||||
|
||||
// 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 "CreatePlayerSessions"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the game session to add players to.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameSessionId() const{ return m_gameSessionId; }
|
||||
inline bool GameSessionIdHasBeenSet() const { return m_gameSessionIdHasBeenSet; }
|
||||
inline void SetGameSessionId(const Aws::String& value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId = value; }
|
||||
inline void SetGameSessionId(Aws::String&& value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId = std::move(value); }
|
||||
inline void SetGameSessionId(const char* value) { m_gameSessionIdHasBeenSet = true; m_gameSessionId.assign(value); }
|
||||
inline CreatePlayerSessionsRequest& WithGameSessionId(const Aws::String& value) { SetGameSessionId(value); return *this;}
|
||||
inline CreatePlayerSessionsRequest& WithGameSessionId(Aws::String&& value) { SetGameSessionId(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionsRequest& WithGameSessionId(const char* value) { SetGameSessionId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>List of unique identifiers for the players to be added.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetPlayerIds() const{ return m_playerIds; }
|
||||
inline bool PlayerIdsHasBeenSet() const { return m_playerIdsHasBeenSet; }
|
||||
inline void SetPlayerIds(const Aws::Vector<Aws::String>& value) { m_playerIdsHasBeenSet = true; m_playerIds = value; }
|
||||
inline void SetPlayerIds(Aws::Vector<Aws::String>&& value) { m_playerIdsHasBeenSet = true; m_playerIds = std::move(value); }
|
||||
inline CreatePlayerSessionsRequest& WithPlayerIds(const Aws::Vector<Aws::String>& value) { SetPlayerIds(value); return *this;}
|
||||
inline CreatePlayerSessionsRequest& WithPlayerIds(Aws::Vector<Aws::String>&& value) { SetPlayerIds(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionsRequest& AddPlayerIds(const Aws::String& value) { m_playerIdsHasBeenSet = true; m_playerIds.push_back(value); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerIds(Aws::String&& value) { m_playerIdsHasBeenSet = true; m_playerIds.push_back(std::move(value)); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerIds(const char* value) { m_playerIdsHasBeenSet = true; m_playerIds.push_back(value); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Map of string pairs, each specifying a player ID and a set of
|
||||
* developer-defined information related to the player. Amazon GameLift does not
|
||||
* use this data, so it can be formatted as needed for use in the game. Any player
|
||||
* data strings for player IDs that are not included in the <code>PlayerIds</code>
|
||||
* parameter are ignored. </p>
|
||||
*/
|
||||
inline const Aws::Map<Aws::String, Aws::String>& GetPlayerDataMap() const{ return m_playerDataMap; }
|
||||
inline bool PlayerDataMapHasBeenSet() const { return m_playerDataMapHasBeenSet; }
|
||||
inline void SetPlayerDataMap(const Aws::Map<Aws::String, Aws::String>& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap = value; }
|
||||
inline void SetPlayerDataMap(Aws::Map<Aws::String, Aws::String>&& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap = std::move(value); }
|
||||
inline CreatePlayerSessionsRequest& WithPlayerDataMap(const Aws::Map<Aws::String, Aws::String>& value) { SetPlayerDataMap(value); return *this;}
|
||||
inline CreatePlayerSessionsRequest& WithPlayerDataMap(Aws::Map<Aws::String, Aws::String>&& value) { SetPlayerDataMap(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(const Aws::String& key, const Aws::String& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(key, value); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(Aws::String&& key, const Aws::String& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(std::move(key), value); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(const Aws::String& key, Aws::String&& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(key, std::move(value)); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(Aws::String&& key, Aws::String&& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(std::move(key), std::move(value)); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(const char* key, Aws::String&& value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(key, std::move(value)); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(Aws::String&& key, const char* value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(std::move(key), value); return *this; }
|
||||
inline CreatePlayerSessionsRequest& AddPlayerDataMap(const char* key, const char* value) { m_playerDataMapHasBeenSet = true; m_playerDataMap.emplace(key, value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_gameSessionId;
|
||||
bool m_gameSessionIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_playerIds;
|
||||
bool m_playerIdsHasBeenSet = false;
|
||||
|
||||
Aws::Map<Aws::String, Aws::String> m_playerDataMap;
|
||||
bool m_playerDataMapHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/PlayerSession.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreatePlayerSessionsResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreatePlayerSessionsResult();
|
||||
AWS_GAMELIFT_API CreatePlayerSessionsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreatePlayerSessionsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A collection of player session objects created for the added players.</p>
|
||||
*/
|
||||
inline const Aws::Vector<PlayerSession>& GetPlayerSessions() const{ return m_playerSessions; }
|
||||
inline void SetPlayerSessions(const Aws::Vector<PlayerSession>& value) { m_playerSessions = value; }
|
||||
inline void SetPlayerSessions(Aws::Vector<PlayerSession>&& value) { m_playerSessions = std::move(value); }
|
||||
inline CreatePlayerSessionsResult& WithPlayerSessions(const Aws::Vector<PlayerSession>& value) { SetPlayerSessions(value); return *this;}
|
||||
inline CreatePlayerSessionsResult& WithPlayerSessions(Aws::Vector<PlayerSession>&& value) { SetPlayerSessions(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionsResult& AddPlayerSessions(const PlayerSession& value) { m_playerSessions.push_back(value); return *this; }
|
||||
inline CreatePlayerSessionsResult& AddPlayerSessions(PlayerSession&& value) { m_playerSessions.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreatePlayerSessionsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreatePlayerSessionsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreatePlayerSessionsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::Vector<PlayerSession> m_playerSessions;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/S3Location.h>
|
||||
#include <aws/core/utils/Array.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/Tag.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateScriptRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateScriptRequest();
|
||||
|
||||
// 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 "CreateScript"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with a script. Script names do not
|
||||
* need to be unique. You can use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateScript.html">UpdateScript</a>
|
||||
* to change this value later. </p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline CreateScriptRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline CreateScriptRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline CreateScriptRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Version information that is associated with a build or script. Version
|
||||
* strings do not need to be unique. You can use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateScript.html">UpdateScript</a>
|
||||
* to change this value later. </p>
|
||||
*/
|
||||
inline const Aws::String& GetVersion() const{ return m_version; }
|
||||
inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
|
||||
inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
|
||||
inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
|
||||
inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
|
||||
inline CreateScriptRequest& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
|
||||
inline CreateScriptRequest& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
|
||||
inline CreateScriptRequest& WithVersion(const char* value) { SetVersion(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The location of the Amazon S3 bucket where a zipped file containing your
|
||||
* Realtime scripts is stored. The storage location must specify the Amazon S3
|
||||
* bucket name, the zip file name (the "key"), and a role ARN that allows Amazon
|
||||
* GameLift to access the Amazon S3 storage location. The S3 bucket must be in the
|
||||
* same Region where you want to create a new script. By default, Amazon GameLift
|
||||
* uploads the latest version of the zip file; if you have S3 object versioning
|
||||
* turned on, you can use the <code>ObjectVersion</code> parameter to specify an
|
||||
* earlier version. </p>
|
||||
*/
|
||||
inline const S3Location& GetStorageLocation() const{ return m_storageLocation; }
|
||||
inline bool StorageLocationHasBeenSet() const { return m_storageLocationHasBeenSet; }
|
||||
inline void SetStorageLocation(const S3Location& value) { m_storageLocationHasBeenSet = true; m_storageLocation = value; }
|
||||
inline void SetStorageLocation(S3Location&& value) { m_storageLocationHasBeenSet = true; m_storageLocation = std::move(value); }
|
||||
inline CreateScriptRequest& WithStorageLocation(const S3Location& value) { SetStorageLocation(value); return *this;}
|
||||
inline CreateScriptRequest& WithStorageLocation(S3Location&& value) { SetStorageLocation(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A data object containing your Realtime scripts and dependencies as a zip
|
||||
* file. The zip file can have one or multiple files. Maximum size of a zip file is
|
||||
* 5 MB.</p> <p>When using the Amazon Web Services CLI tool to create a script,
|
||||
* this parameter is set to the zip file name. It must be prepended with the string
|
||||
* "fileb://" to indicate that the file data is a binary object. For example:
|
||||
* <code>--zip-file fileb://myRealtimeScript.zip</code>.</p>
|
||||
*/
|
||||
inline const Aws::Utils::ByteBuffer& GetZipFile() const{ return m_zipFile; }
|
||||
inline bool ZipFileHasBeenSet() const { return m_zipFileHasBeenSet; }
|
||||
inline void SetZipFile(const Aws::Utils::ByteBuffer& value) { m_zipFileHasBeenSet = true; m_zipFile = value; }
|
||||
inline void SetZipFile(Aws::Utils::ByteBuffer&& value) { m_zipFileHasBeenSet = true; m_zipFile = std::move(value); }
|
||||
inline CreateScriptRequest& WithZipFile(const Aws::Utils::ByteBuffer& value) { SetZipFile(value); return *this;}
|
||||
inline CreateScriptRequest& WithZipFile(Aws::Utils::ByteBuffer&& value) { SetZipFile(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A list of labels to assign to the new script resource. Tags are
|
||||
* developer-defined key-value pairs. Tagging Amazon Web Services resources are
|
||||
* useful for resource management, access management and cost allocation. For more
|
||||
* information, see <a
|
||||
* href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html"> Tagging
|
||||
* Amazon Web Services Resources</a> in the <i>Amazon Web Services General
|
||||
* Reference</i>. Once the resource is created, you can use <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_TagResource.html">TagResource</a>,
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_UntagResource.html">UntagResource</a>,
|
||||
* and <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_ListTagsForResource.html">ListTagsForResource</a>
|
||||
* to add, remove, and view tags. The maximum tag limit may be lower than stated.
|
||||
* See the Amazon Web Services General Reference for actual tagging limits.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
|
||||
inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
|
||||
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
|
||||
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
|
||||
inline CreateScriptRequest& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
|
||||
inline CreateScriptRequest& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
|
||||
inline CreateScriptRequest& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
|
||||
inline CreateScriptRequest& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
Aws::String m_version;
|
||||
bool m_versionHasBeenSet = false;
|
||||
|
||||
S3Location m_storageLocation;
|
||||
bool m_storageLocationHasBeenSet = false;
|
||||
|
||||
Aws::Utils::ByteBuffer m_zipFile;
|
||||
bool m_zipFileHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Tag> m_tags;
|
||||
bool m_tagsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/Script.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateScriptResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateScriptResult();
|
||||
AWS_GAMELIFT_API CreateScriptResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateScriptResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The newly created script record with a unique script ID and ARN. The new
|
||||
* script's storage location reflects an Amazon S3 location: (1) If the script was
|
||||
* uploaded from an S3 bucket under your account, the storage location reflects the
|
||||
* information that was provided in the <i>CreateScript</i> request; (2) If the
|
||||
* script file was uploaded from a local zip file, the storage location reflects an
|
||||
* S3 location controls by the Amazon GameLift service.</p>
|
||||
*/
|
||||
inline const Script& GetScript() const{ return m_script; }
|
||||
inline void SetScript(const Script& value) { m_script = value; }
|
||||
inline void SetScript(Script&& value) { m_script = std::move(value); }
|
||||
inline CreateScriptResult& WithScript(const Script& value) { SetScript(value); return *this;}
|
||||
inline CreateScriptResult& WithScript(Script&& value) { SetScript(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateScriptResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateScriptResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateScriptResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Script m_script;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateVpcPeeringAuthorizationRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateVpcPeeringAuthorizationRequest();
|
||||
|
||||
// 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 "CreateVpcPeeringAuthorization"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the Amazon Web Services account that you use to
|
||||
* manage your Amazon GameLift fleet. You can find your Account ID in the Amazon
|
||||
* Web Services Management Console under account settings.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameLiftAwsAccountId() const{ return m_gameLiftAwsAccountId; }
|
||||
inline bool GameLiftAwsAccountIdHasBeenSet() const { return m_gameLiftAwsAccountIdHasBeenSet; }
|
||||
inline void SetGameLiftAwsAccountId(const Aws::String& value) { m_gameLiftAwsAccountIdHasBeenSet = true; m_gameLiftAwsAccountId = value; }
|
||||
inline void SetGameLiftAwsAccountId(Aws::String&& value) { m_gameLiftAwsAccountIdHasBeenSet = true; m_gameLiftAwsAccountId = std::move(value); }
|
||||
inline void SetGameLiftAwsAccountId(const char* value) { m_gameLiftAwsAccountIdHasBeenSet = true; m_gameLiftAwsAccountId.assign(value); }
|
||||
inline CreateVpcPeeringAuthorizationRequest& WithGameLiftAwsAccountId(const Aws::String& value) { SetGameLiftAwsAccountId(value); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationRequest& WithGameLiftAwsAccountId(Aws::String&& value) { SetGameLiftAwsAccountId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationRequest& WithGameLiftAwsAccountId(const char* value) { SetGameLiftAwsAccountId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a VPC with resources to be accessed by your Amazon
|
||||
* GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
|
||||
* VPC ID, use the <a href="https://console.aws.amazon.com/vpc/">VPC Dashboard</a>
|
||||
* in the Amazon Web Services Management Console. Learn more about VPC peering in
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html">VPC
|
||||
* Peering with Amazon GameLift Fleets</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPeerVpcId() const{ return m_peerVpcId; }
|
||||
inline bool PeerVpcIdHasBeenSet() const { return m_peerVpcIdHasBeenSet; }
|
||||
inline void SetPeerVpcId(const Aws::String& value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId = value; }
|
||||
inline void SetPeerVpcId(Aws::String&& value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId = std::move(value); }
|
||||
inline void SetPeerVpcId(const char* value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId.assign(value); }
|
||||
inline CreateVpcPeeringAuthorizationRequest& WithPeerVpcId(const Aws::String& value) { SetPeerVpcId(value); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationRequest& WithPeerVpcId(Aws::String&& value) { SetPeerVpcId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationRequest& WithPeerVpcId(const char* value) { SetPeerVpcId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_gameLiftAwsAccountId;
|
||||
bool m_gameLiftAwsAccountIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_peerVpcId;
|
||||
bool m_peerVpcIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/VpcPeeringAuthorization.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateVpcPeeringAuthorizationResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateVpcPeeringAuthorizationResult();
|
||||
AWS_GAMELIFT_API CreateVpcPeeringAuthorizationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateVpcPeeringAuthorizationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>Details on the requested VPC peering authorization, including expiration.</p>
|
||||
*/
|
||||
inline const VpcPeeringAuthorization& GetVpcPeeringAuthorization() const{ return m_vpcPeeringAuthorization; }
|
||||
inline void SetVpcPeeringAuthorization(const VpcPeeringAuthorization& value) { m_vpcPeeringAuthorization = value; }
|
||||
inline void SetVpcPeeringAuthorization(VpcPeeringAuthorization&& value) { m_vpcPeeringAuthorization = std::move(value); }
|
||||
inline CreateVpcPeeringAuthorizationResult& WithVpcPeeringAuthorization(const VpcPeeringAuthorization& value) { SetVpcPeeringAuthorization(value); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationResult& WithVpcPeeringAuthorization(VpcPeeringAuthorization&& value) { SetVpcPeeringAuthorization(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateVpcPeeringAuthorizationResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringAuthorizationResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
VpcPeeringAuthorization m_vpcPeeringAuthorization;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class CreateVpcPeeringConnectionRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateVpcPeeringConnectionRequest();
|
||||
|
||||
// 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 "CreateVpcPeeringConnection"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet. You can use either the fleet ID or ARN
|
||||
* value. This tells Amazon GameLift which GameLift VPC to peer with. </p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline CreateVpcPeeringConnectionRequest& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline CreateVpcPeeringConnectionRequest& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringConnectionRequest& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the Amazon Web Services account with the VPC that you
|
||||
* want to peer your Amazon GameLift fleet with. You can find your Account ID in
|
||||
* the Amazon Web Services Management Console under account settings.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPeerVpcAwsAccountId() const{ return m_peerVpcAwsAccountId; }
|
||||
inline bool PeerVpcAwsAccountIdHasBeenSet() const { return m_peerVpcAwsAccountIdHasBeenSet; }
|
||||
inline void SetPeerVpcAwsAccountId(const Aws::String& value) { m_peerVpcAwsAccountIdHasBeenSet = true; m_peerVpcAwsAccountId = value; }
|
||||
inline void SetPeerVpcAwsAccountId(Aws::String&& value) { m_peerVpcAwsAccountIdHasBeenSet = true; m_peerVpcAwsAccountId = std::move(value); }
|
||||
inline void SetPeerVpcAwsAccountId(const char* value) { m_peerVpcAwsAccountIdHasBeenSet = true; m_peerVpcAwsAccountId.assign(value); }
|
||||
inline CreateVpcPeeringConnectionRequest& WithPeerVpcAwsAccountId(const Aws::String& value) { SetPeerVpcAwsAccountId(value); return *this;}
|
||||
inline CreateVpcPeeringConnectionRequest& WithPeerVpcAwsAccountId(Aws::String&& value) { SetPeerVpcAwsAccountId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringConnectionRequest& WithPeerVpcAwsAccountId(const char* value) { SetPeerVpcAwsAccountId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for a VPC with resources to be accessed by your Amazon
|
||||
* GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
|
||||
* VPC ID, use the <a href="https://console.aws.amazon.com/vpc/">VPC Dashboard</a>
|
||||
* in the Amazon Web Services Management Console. Learn more about VPC peering in
|
||||
* <a
|
||||
* href="https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html">VPC
|
||||
* Peering with Amazon GameLift Fleets</a>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetPeerVpcId() const{ return m_peerVpcId; }
|
||||
inline bool PeerVpcIdHasBeenSet() const { return m_peerVpcIdHasBeenSet; }
|
||||
inline void SetPeerVpcId(const Aws::String& value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId = value; }
|
||||
inline void SetPeerVpcId(Aws::String&& value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId = std::move(value); }
|
||||
inline void SetPeerVpcId(const char* value) { m_peerVpcIdHasBeenSet = true; m_peerVpcId.assign(value); }
|
||||
inline CreateVpcPeeringConnectionRequest& WithPeerVpcId(const Aws::String& value) { SetPeerVpcId(value); return *this;}
|
||||
inline CreateVpcPeeringConnectionRequest& WithPeerVpcId(Aws::String&& value) { SetPeerVpcId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringConnectionRequest& WithPeerVpcId(const char* value) { SetPeerVpcId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_peerVpcAwsAccountId;
|
||||
bool m_peerVpcAwsAccountIdHasBeenSet = false;
|
||||
|
||||
Aws::String m_peerVpcId;
|
||||
bool m_peerVpcIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class CreateVpcPeeringConnectionResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API CreateVpcPeeringConnectionResult();
|
||||
AWS_GAMELIFT_API CreateVpcPeeringConnectionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API CreateVpcPeeringConnectionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline CreateVpcPeeringConnectionResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline CreateVpcPeeringConnectionResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline CreateVpcPeeringConnectionResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteAliasRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteAliasRequest();
|
||||
|
||||
// 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 "DeleteAlias"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier of the alias that you want to delete. You can use either
|
||||
* the alias ID or ARN value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetAliasId() const{ return m_aliasId; }
|
||||
inline bool AliasIdHasBeenSet() const { return m_aliasIdHasBeenSet; }
|
||||
inline void SetAliasId(const Aws::String& value) { m_aliasIdHasBeenSet = true; m_aliasId = value; }
|
||||
inline void SetAliasId(Aws::String&& value) { m_aliasIdHasBeenSet = true; m_aliasId = std::move(value); }
|
||||
inline void SetAliasId(const char* value) { m_aliasIdHasBeenSet = true; m_aliasId.assign(value); }
|
||||
inline DeleteAliasRequest& WithAliasId(const Aws::String& value) { SetAliasId(value); return *this;}
|
||||
inline DeleteAliasRequest& WithAliasId(Aws::String&& value) { SetAliasId(std::move(value)); return *this;}
|
||||
inline DeleteAliasRequest& WithAliasId(const char* value) { SetAliasId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_aliasId;
|
||||
bool m_aliasIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteBuildRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteBuildRequest();
|
||||
|
||||
// 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 "DeleteBuild"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the build to delete. You can use either the build ID
|
||||
* or ARN value. </p>
|
||||
*/
|
||||
inline const Aws::String& GetBuildId() const{ return m_buildId; }
|
||||
inline bool BuildIdHasBeenSet() const { return m_buildIdHasBeenSet; }
|
||||
inline void SetBuildId(const Aws::String& value) { m_buildIdHasBeenSet = true; m_buildId = value; }
|
||||
inline void SetBuildId(Aws::String&& value) { m_buildIdHasBeenSet = true; m_buildId = std::move(value); }
|
||||
inline void SetBuildId(const char* value) { m_buildIdHasBeenSet = true; m_buildId.assign(value); }
|
||||
inline DeleteBuildRequest& WithBuildId(const Aws::String& value) { SetBuildId(value); return *this;}
|
||||
inline DeleteBuildRequest& WithBuildId(Aws::String&& value) { SetBuildId(std::move(value)); return *this;}
|
||||
inline DeleteBuildRequest& WithBuildId(const char* value) { SetBuildId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_buildId;
|
||||
bool m_buildIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteContainerFleetRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteContainerFleetRequest();
|
||||
|
||||
// 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 "DeleteContainerFleet"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the container fleet to delete. You can use either the
|
||||
* fleet ID or ARN value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline DeleteContainerFleetRequest& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline DeleteContainerFleetRequest& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline DeleteContainerFleetRequest& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteContainerFleetResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteContainerFleetResult();
|
||||
AWS_GAMELIFT_API DeleteContainerFleetResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteContainerFleetResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteContainerFleetResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteContainerFleetResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteContainerFleetResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteContainerGroupDefinitionRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteContainerGroupDefinitionRequest();
|
||||
|
||||
// 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 "DeleteContainerGroupDefinition"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The unique identifier for the container group definition to delete. You can
|
||||
* use either the <code>Name</code> or <code>ARN</code> value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline DeleteContainerGroupDefinitionRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline DeleteContainerGroupDefinitionRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline DeleteContainerGroupDefinitionRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The specific version to delete.</p>
|
||||
*/
|
||||
inline int GetVersionNumber() const{ return m_versionNumber; }
|
||||
inline bool VersionNumberHasBeenSet() const { return m_versionNumberHasBeenSet; }
|
||||
inline void SetVersionNumber(int value) { m_versionNumberHasBeenSet = true; m_versionNumber = value; }
|
||||
inline DeleteContainerGroupDefinitionRequest& WithVersionNumber(int value) { SetVersionNumber(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The number of most recent versions to keep while deleting all older
|
||||
* versions.</p>
|
||||
*/
|
||||
inline int GetVersionCountToRetain() const{ return m_versionCountToRetain; }
|
||||
inline bool VersionCountToRetainHasBeenSet() const { return m_versionCountToRetainHasBeenSet; }
|
||||
inline void SetVersionCountToRetain(int value) { m_versionCountToRetainHasBeenSet = true; m_versionCountToRetain = value; }
|
||||
inline DeleteContainerGroupDefinitionRequest& WithVersionCountToRetain(int value) { SetVersionCountToRetain(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
|
||||
int m_versionNumber;
|
||||
bool m_versionNumberHasBeenSet = false;
|
||||
|
||||
int m_versionCountToRetain;
|
||||
bool m_versionCountToRetainHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteContainerGroupDefinitionResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteContainerGroupDefinitionResult();
|
||||
AWS_GAMELIFT_API DeleteContainerGroupDefinitionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteContainerGroupDefinitionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteContainerGroupDefinitionResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteContainerGroupDefinitionResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteContainerGroupDefinitionResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,79 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteFleetLocationsRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteFleetLocationsRequest();
|
||||
|
||||
// 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 "DeleteFleetLocations"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet to delete locations for. You can use either
|
||||
* the fleet ID or ARN value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline DeleteFleetLocationsRequest& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline DeleteFleetLocationsRequest& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline DeleteFleetLocationsRequest& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The list of fleet locations to delete. Specify locations in the form of an
|
||||
* Amazon Web Services Region code, such as <code>us-west-2</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<Aws::String>& GetLocations() const{ return m_locations; }
|
||||
inline bool LocationsHasBeenSet() const { return m_locationsHasBeenSet; }
|
||||
inline void SetLocations(const Aws::Vector<Aws::String>& value) { m_locationsHasBeenSet = true; m_locations = value; }
|
||||
inline void SetLocations(Aws::Vector<Aws::String>&& value) { m_locationsHasBeenSet = true; m_locations = std::move(value); }
|
||||
inline DeleteFleetLocationsRequest& WithLocations(const Aws::Vector<Aws::String>& value) { SetLocations(value); return *this;}
|
||||
inline DeleteFleetLocationsRequest& WithLocations(Aws::Vector<Aws::String>&& value) { SetLocations(std::move(value)); return *this;}
|
||||
inline DeleteFleetLocationsRequest& AddLocations(const Aws::String& value) { m_locationsHasBeenSet = true; m_locations.push_back(value); return *this; }
|
||||
inline DeleteFleetLocationsRequest& AddLocations(Aws::String&& value) { m_locationsHasBeenSet = true; m_locations.push_back(std::move(value)); return *this; }
|
||||
inline DeleteFleetLocationsRequest& AddLocations(const char* value) { m_locationsHasBeenSet = true; m_locations.push_back(value); return *this; }
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
|
||||
Aws::Vector<Aws::String> m_locations;
|
||||
bool m_locationsHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,105 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/core/utils/memory/stl/AWSVector.h>
|
||||
#include <aws/gamelift/model/LocationState.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteFleetLocationsResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteFleetLocationsResult();
|
||||
AWS_GAMELIFT_API DeleteFleetLocationsResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteFleetLocationsResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet that location attributes are being deleted
|
||||
* for.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetId.assign(value); }
|
||||
inline DeleteFleetLocationsResult& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The Amazon Resource Name (<a
|
||||
* href="https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html">ARN</a>)
|
||||
* that is assigned to a Amazon GameLift fleet resource and uniquely identifies it.
|
||||
* ARNs are unique across all Regions. Format is
|
||||
* <code>arn:aws:gamelift:<region>::fleet/fleet-a1234567-b8c9-0d1e-2fa3-b45c6d7e8912</code>.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetArn() const{ return m_fleetArn; }
|
||||
inline void SetFleetArn(const Aws::String& value) { m_fleetArn = value; }
|
||||
inline void SetFleetArn(Aws::String&& value) { m_fleetArn = std::move(value); }
|
||||
inline void SetFleetArn(const char* value) { m_fleetArn.assign(value); }
|
||||
inline DeleteFleetLocationsResult& WithFleetArn(const Aws::String& value) { SetFleetArn(value); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithFleetArn(Aws::String&& value) { SetFleetArn(std::move(value)); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithFleetArn(const char* value) { SetFleetArn(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The remote locations that are being deleted, with each location status set to
|
||||
* <code>DELETING</code>.</p>
|
||||
*/
|
||||
inline const Aws::Vector<LocationState>& GetLocationStates() const{ return m_locationStates; }
|
||||
inline void SetLocationStates(const Aws::Vector<LocationState>& value) { m_locationStates = value; }
|
||||
inline void SetLocationStates(Aws::Vector<LocationState>&& value) { m_locationStates = std::move(value); }
|
||||
inline DeleteFleetLocationsResult& WithLocationStates(const Aws::Vector<LocationState>& value) { SetLocationStates(value); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithLocationStates(Aws::Vector<LocationState>&& value) { SetLocationStates(std::move(value)); return *this;}
|
||||
inline DeleteFleetLocationsResult& AddLocationStates(const LocationState& value) { m_locationStates.push_back(value); return *this; }
|
||||
inline DeleteFleetLocationsResult& AddLocationStates(LocationState&& value) { m_locationStates.push_back(std::move(value)); return *this; }
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteFleetLocationsResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteFleetLocationsResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
|
||||
Aws::String m_fleetArn;
|
||||
|
||||
Aws::Vector<LocationState> m_locationStates;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteFleetRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteFleetRequest();
|
||||
|
||||
// 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 "DeleteFleet"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the fleet to be deleted. You can use either the fleet
|
||||
* ID or ARN value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetFleetId() const{ return m_fleetId; }
|
||||
inline bool FleetIdHasBeenSet() const { return m_fleetIdHasBeenSet; }
|
||||
inline void SetFleetId(const Aws::String& value) { m_fleetIdHasBeenSet = true; m_fleetId = value; }
|
||||
inline void SetFleetId(Aws::String&& value) { m_fleetIdHasBeenSet = true; m_fleetId = std::move(value); }
|
||||
inline void SetFleetId(const char* value) { m_fleetIdHasBeenSet = true; m_fleetId.assign(value); }
|
||||
inline DeleteFleetRequest& WithFleetId(const Aws::String& value) { SetFleetId(value); return *this;}
|
||||
inline DeleteFleetRequest& WithFleetId(Aws::String&& value) { SetFleetId(std::move(value)); return *this;}
|
||||
inline DeleteFleetRequest& WithFleetId(const char* value) { SetFleetId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_fleetId;
|
||||
bool m_fleetIdHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <aws/gamelift/model/GameServerGroupDeleteOption.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteGameServerGroupRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteGameServerGroupRequest();
|
||||
|
||||
// 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 "DeleteGameServerGroup"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the game server group. Use either the name or ARN
|
||||
* value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetGameServerGroupName() const{ return m_gameServerGroupName; }
|
||||
inline bool GameServerGroupNameHasBeenSet() const { return m_gameServerGroupNameHasBeenSet; }
|
||||
inline void SetGameServerGroupName(const Aws::String& value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName = value; }
|
||||
inline void SetGameServerGroupName(Aws::String&& value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName = std::move(value); }
|
||||
inline void SetGameServerGroupName(const char* value) { m_gameServerGroupNameHasBeenSet = true; m_gameServerGroupName.assign(value); }
|
||||
inline DeleteGameServerGroupRequest& WithGameServerGroupName(const Aws::String& value) { SetGameServerGroupName(value); return *this;}
|
||||
inline DeleteGameServerGroupRequest& WithGameServerGroupName(Aws::String&& value) { SetGameServerGroupName(std::move(value)); return *this;}
|
||||
inline DeleteGameServerGroupRequest& WithGameServerGroupName(const char* value) { SetGameServerGroupName(value); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The type of delete to perform. Options include the following:</p> <ul> <li>
|
||||
* <p> <code>SAFE_DELETE</code> – (default) Terminates the game server group and
|
||||
* Amazon EC2 Auto Scaling group only when it has no game servers that are in
|
||||
* <code>UTILIZED</code> status.</p> </li> <li> <p> <code>FORCE_DELETE</code> –
|
||||
* Terminates the game server group, including all active game servers regardless
|
||||
* of their utilization status, and the Amazon EC2 Auto Scaling group. </p> </li>
|
||||
* <li> <p> <code>RETAIN</code> – Does a safe delete of the game server group but
|
||||
* retains the Amazon EC2 Auto Scaling group as is.</p> </li> </ul>
|
||||
*/
|
||||
inline const GameServerGroupDeleteOption& GetDeleteOption() const{ return m_deleteOption; }
|
||||
inline bool DeleteOptionHasBeenSet() const { return m_deleteOptionHasBeenSet; }
|
||||
inline void SetDeleteOption(const GameServerGroupDeleteOption& value) { m_deleteOptionHasBeenSet = true; m_deleteOption = value; }
|
||||
inline void SetDeleteOption(GameServerGroupDeleteOption&& value) { m_deleteOptionHasBeenSet = true; m_deleteOption = std::move(value); }
|
||||
inline DeleteGameServerGroupRequest& WithDeleteOption(const GameServerGroupDeleteOption& value) { SetDeleteOption(value); return *this;}
|
||||
inline DeleteGameServerGroupRequest& WithDeleteOption(GameServerGroupDeleteOption&& value) { SetDeleteOption(std::move(value)); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_gameServerGroupName;
|
||||
bool m_gameServerGroupNameHasBeenSet = false;
|
||||
|
||||
GameServerGroupDeleteOption m_deleteOption;
|
||||
bool m_deleteOptionHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/model/GameServerGroup.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteGameServerGroupResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteGameServerGroupResult();
|
||||
AWS_GAMELIFT_API DeleteGameServerGroupResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteGameServerGroupResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>An object that describes the deleted game server group resource, with status
|
||||
* updated to <code>DELETE_SCHEDULED</code>. </p>
|
||||
*/
|
||||
inline const GameServerGroup& GetGameServerGroup() const{ return m_gameServerGroup; }
|
||||
inline void SetGameServerGroup(const GameServerGroup& value) { m_gameServerGroup = value; }
|
||||
inline void SetGameServerGroup(GameServerGroup&& value) { m_gameServerGroup = std::move(value); }
|
||||
inline DeleteGameServerGroupResult& WithGameServerGroup(const GameServerGroup& value) { SetGameServerGroup(value); return *this;}
|
||||
inline DeleteGameServerGroupResult& WithGameServerGroup(GameServerGroup&& value) { SetGameServerGroup(std::move(value)); return *this;}
|
||||
///@}
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteGameServerGroupResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteGameServerGroupResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteGameServerGroupResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
GameServerGroup m_gameServerGroup;
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteGameSessionQueueRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteGameSessionQueueRequest();
|
||||
|
||||
// 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 "DeleteGameSessionQueue"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A descriptive label that is associated with game session queue. Queue names
|
||||
* must be unique within each Region. You can use either the queue ID or ARN value.
|
||||
* </p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline DeleteGameSessionQueueRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline DeleteGameSessionQueueRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline DeleteGameSessionQueueRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteGameSessionQueueResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteGameSessionQueueResult();
|
||||
AWS_GAMELIFT_API DeleteGameSessionQueueResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteGameSessionQueueResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteGameSessionQueueResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteGameSessionQueueResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteGameSessionQueueResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteLocationRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteLocationRequest();
|
||||
|
||||
// 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 "DeleteLocation"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>The location name of the custom location to be deleted.</p>
|
||||
*/
|
||||
inline const Aws::String& GetLocationName() const{ return m_locationName; }
|
||||
inline bool LocationNameHasBeenSet() const { return m_locationNameHasBeenSet; }
|
||||
inline void SetLocationName(const Aws::String& value) { m_locationNameHasBeenSet = true; m_locationName = value; }
|
||||
inline void SetLocationName(Aws::String&& value) { m_locationNameHasBeenSet = true; m_locationName = std::move(value); }
|
||||
inline void SetLocationName(const char* value) { m_locationNameHasBeenSet = true; m_locationName.assign(value); }
|
||||
inline DeleteLocationRequest& WithLocationName(const Aws::String& value) { SetLocationName(value); return *this;}
|
||||
inline DeleteLocationRequest& WithLocationName(Aws::String&& value) { SetLocationName(std::move(value)); return *this;}
|
||||
inline DeleteLocationRequest& WithLocationName(const char* value) { SetLocationName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_locationName;
|
||||
bool m_locationNameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteLocationResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteLocationResult();
|
||||
AWS_GAMELIFT_API DeleteLocationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteLocationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteLocationResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteLocationResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteLocationResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/gamelift/GameLiftRequest.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
|
||||
/**
|
||||
*/
|
||||
class DeleteMatchmakingConfigurationRequest : public GameLiftRequest
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteMatchmakingConfigurationRequest();
|
||||
|
||||
// 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 "DeleteMatchmakingConfiguration"; }
|
||||
|
||||
AWS_GAMELIFT_API Aws::String SerializePayload() const override;
|
||||
|
||||
AWS_GAMELIFT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
|
||||
|
||||
|
||||
///@{
|
||||
/**
|
||||
* <p>A unique identifier for the matchmaking configuration. You can use either the
|
||||
* configuration name or ARN value.</p>
|
||||
*/
|
||||
inline const Aws::String& GetName() const{ return m_name; }
|
||||
inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
|
||||
inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
|
||||
inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
|
||||
inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
|
||||
inline DeleteMatchmakingConfigurationRequest& WithName(const Aws::String& value) { SetName(value); return *this;}
|
||||
inline DeleteMatchmakingConfigurationRequest& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
|
||||
inline DeleteMatchmakingConfigurationRequest& WithName(const char* value) { SetName(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_name;
|
||||
bool m_nameHasBeenSet = false;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
* SPDX-License-Identifier: Apache-2.0.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <aws/gamelift/GameLift_EXPORTS.h>
|
||||
#include <aws/core/utils/memory/stl/AWSString.h>
|
||||
#include <utility>
|
||||
|
||||
namespace Aws
|
||||
{
|
||||
template<typename RESULT_TYPE>
|
||||
class AmazonWebServiceResult;
|
||||
|
||||
namespace Utils
|
||||
{
|
||||
namespace Json
|
||||
{
|
||||
class JsonValue;
|
||||
} // namespace Json
|
||||
} // namespace Utils
|
||||
namespace GameLift
|
||||
{
|
||||
namespace Model
|
||||
{
|
||||
class DeleteMatchmakingConfigurationResult
|
||||
{
|
||||
public:
|
||||
AWS_GAMELIFT_API DeleteMatchmakingConfigurationResult();
|
||||
AWS_GAMELIFT_API DeleteMatchmakingConfigurationResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
AWS_GAMELIFT_API DeleteMatchmakingConfigurationResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
|
||||
|
||||
|
||||
///@{
|
||||
|
||||
inline const Aws::String& GetRequestId() const{ return m_requestId; }
|
||||
inline void SetRequestId(const Aws::String& value) { m_requestId = value; }
|
||||
inline void SetRequestId(Aws::String&& value) { m_requestId = std::move(value); }
|
||||
inline void SetRequestId(const char* value) { m_requestId.assign(value); }
|
||||
inline DeleteMatchmakingConfigurationResult& WithRequestId(const Aws::String& value) { SetRequestId(value); return *this;}
|
||||
inline DeleteMatchmakingConfigurationResult& WithRequestId(Aws::String&& value) { SetRequestId(std::move(value)); return *this;}
|
||||
inline DeleteMatchmakingConfigurationResult& WithRequestId(const char* value) { SetRequestId(value); return *this;}
|
||||
///@}
|
||||
private:
|
||||
|
||||
Aws::String m_requestId;
|
||||
};
|
||||
|
||||
} // namespace Model
|
||||
} // namespace GameLift
|
||||
} // namespace Aws
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user