ArtifactPackaging GetArtifactPackagingForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == NONE_HASH)
{
return ArtifactPackaging::NONE;
}
else if (hashCode == ZIP_HASH)
{
return ArtifactPackaging::ZIP;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ArtifactPackaging>(hashCode);
}
return ArtifactPackaging::NOT_SET;
}
Owner GetOwnerForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == CUSTOM_LAMBDA_HASH)
{
return Owner::CUSTOM_LAMBDA;
}
else if (hashCode == AWS_HASH)
{
return Owner::AWS;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<Owner>(hashCode);
}
return Owner::NOT_SET;
}
SortOrder GetSortOrderForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == asc_HASH)
{
return SortOrder::asc;
}
else if (hashCode == dsc_HASH)
{
return SortOrder::dsc;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<SortOrder>(hashCode);
}
return SortOrder::NOT_SET;
}
ExpirationStatus GetExpirationStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == Enabled_HASH)
{
return ExpirationStatus::Enabled;
}
else if (hashCode == Disabled_HASH)
{
return ExpirationStatus::Disabled;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ExpirationStatus>(hashCode);
}
return ExpirationStatus::NOT_SET;
}
OrderEnum GetOrderEnumForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == ascending_HASH)
{
return OrderEnum::ascending;
}
else if (hashCode == descending_HASH)
{
return OrderEnum::descending;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<OrderEnum>(hashCode);
}
return OrderEnum::NOT_SET;
}
ContentHandlingStrategy GetContentHandlingStrategyForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == CONVERT_TO_BINARY_HASH)
{
return ContentHandlingStrategy::CONVERT_TO_BINARY;
}
else if (hashCode == CONVERT_TO_TEXT_HASH)
{
return ContentHandlingStrategy::CONVERT_TO_TEXT;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ContentHandlingStrategy>(hashCode);
}
return ContentHandlingStrategy::NOT_SET;
}
RootDeviceType GetRootDeviceTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == ebs_HASH)
{
return RootDeviceType::ebs;
}
else if (hashCode == instance_store_HASH)
{
return RootDeviceType::instance_store;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<RootDeviceType>(hashCode);
}
return RootDeviceType::NOT_SET;
}
TagResourceType GetTagResourceTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == healthcheck_HASH)
{
return TagResourceType::healthcheck;
}
else if (hashCode == hostedzone_HASH)
{
return TagResourceType::hostedzone;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<TagResourceType>(hashCode);
}
return TagResourceType::NOT_SET;
}
MarketType GetMarketTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == ON_DEMAND_HASH)
{
return MarketType::ON_DEMAND;
}
else if (hashCode == SPOT_HASH)
{
return MarketType::SPOT;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<MarketType>(hashCode);
}
return MarketType::NOT_SET;
}
LogType GetLogTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == None_HASH)
{
return LogType::None;
}
else if (hashCode == Tail_HASH)
{
return LogType::Tail;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<LogType>(hashCode);
}
return LogType::NOT_SET;
}
KeyType GetKeyTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == HASH_HASH)
{
return KeyType::HASH;
}
else if (hashCode == RANGE_HASH)
{
return KeyType::RANGE;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<KeyType>(hashCode);
}
return KeyType::NOT_SET;
}
AccessDirection GetAccessDirectionForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == inbound_HASH)
{
return AccessDirection::inbound;
}
else if (hashCode == outbound_HASH)
{
return AccessDirection::outbound;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<AccessDirection>(hashCode);
}
return AccessDirection::NOT_SET;
}
ResourceRecordSetFailover GetResourceRecordSetFailoverForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == PRIMARY_HASH)
{
return ResourceRecordSetFailover::PRIMARY;
}
else if (hashCode == SECONDARY_HASH)
{
return ResourceRecordSetFailover::SECONDARY;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ResourceRecordSetFailover>(hashCode);
}
return ResourceRecordSetFailover::NOT_SET;
}
TlsPolicy GetTlsPolicyForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == Require_HASH)
{
return TlsPolicy::Require;
}
else if (hashCode == Optional_HASH)
{
return TlsPolicy::Optional;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<TlsPolicy>(hashCode);
}
return TlsPolicy::NOT_SET;
}
ConfigRuleComplianceSummaryGroupKey GetConfigRuleComplianceSummaryGroupKeyForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == ACCOUNT_ID_HASH)
{
return ConfigRuleComplianceSummaryGroupKey::ACCOUNT_ID;
}
else if (hashCode == AWS_REGION_HASH)
{
return ConfigRuleComplianceSummaryGroupKey::AWS_REGION;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ConfigRuleComplianceSummaryGroupKey>(hashCode);
}
return ConfigRuleComplianceSummaryGroupKey::NOT_SET;
}
TemplateStage GetTemplateStageForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == Original_HASH)
{
return TemplateStage::Original;
}
else if (hashCode == Processed_HASH)
{
return TemplateStage::Processed;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<TemplateStage>(hashCode);
}
return TemplateStage::NOT_SET;
}
Payer GetPayerForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == Requester_HASH)
{
return Payer::Requester;
}
else if (hashCode == BucketOwner_HASH)
{
return Payer::BucketOwner;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<Payer>(hashCode);
}
return Payer::NOT_SET;
}
RoutingStrategyType GetRoutingStrategyTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == SIMPLE_HASH)
{
return RoutingStrategyType::SIMPLE;
}
else if (hashCode == TERMINAL_HASH)
{
return RoutingStrategyType::TERMINAL;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<RoutingStrategyType>(hashCode);
}
return RoutingStrategyType::NOT_SET;
}
DeploymentReadyAction GetDeploymentReadyActionForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == CONTINUE_DEPLOYMENT_HASH)
{
return DeploymentReadyAction::CONTINUE_DEPLOYMENT;
}
else if (hashCode == STOP_DEPLOYMENT_HASH)
{
return DeploymentReadyAction::STOP_DEPLOYMENT;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<DeploymentReadyAction>(hashCode);
}
return DeploymentReadyAction::NOT_SET;
}
ContinuousBackupsStatus GetContinuousBackupsStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == ENABLED_HASH)
{
return ContinuousBackupsStatus::ENABLED;
}
else if (hashCode == DISABLED_HASH)
{
return ContinuousBackupsStatus::DISABLED;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ContinuousBackupsStatus>(hashCode);
}
return ContinuousBackupsStatus::NOT_SET;
}
ValidationSeverity GetValidationSeverityForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == error_HASH)
{
return ValidationSeverity::error;
}
else if (hashCode == warning_HASH)
{
return ValidationSeverity::warning;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ValidationSeverity>(hashCode);
}
return ValidationSeverity::NOT_SET;
}
ContentType GetContentTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == application_json_HASH)
{
return ContentType::application_json;
}
else if (hashCode == application_xml_HASH)
{
return ContentType::application_xml;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ContentType>(hashCode);
}
return ContentType::NOT_SET;
}
ConsistencyLevel GetConsistencyLevelForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == SERIALIZABLE_HASH)
{
return ConsistencyLevel::SERIALIZABLE;
}
else if (hashCode == EVENTUAL_HASH)
{
return ConsistencyLevel::EVENTUAL;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ConsistencyLevel>(hashCode);
}
return ConsistencyLevel::NOT_SET;
}
Aws::String ForRegion(const Aws::String& regionName, bool useDualStack)
{
auto hash = Aws::Utils::HashingUtils::HashString(regionName.c_str());
Aws::StringStream ss;
ss << "gamelift" << ".";
if(useDualStack)
{
ss << "dualstack.";
}
ss << regionName << ".amazonaws.com";
if(hash == CN_REGION_HASH)
{
ss << ".cn";
}
return ss.str();
}
Aws::String ForRegion(const Aws::String& regionName, bool useDualStack)
{
auto hash = Aws::Utils::HashingUtils::HashString(regionName.c_str());
Aws::StringStream ss;
ss << "cognito-idp" << ".";
if(useDualStack)
{
ss << "dualstack.";
}
ss << regionName << ".amazonaws.com";
if (hash == CN_NORTH_HASH || hash == CN_NORTHWEST_1_HASH)
{
ss << ".cn";
}
return ss.str();
}
ClusterStateChangeReasonCode GetClusterStateChangeReasonCodeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == INTERNAL_ERROR_HASH)
{
return ClusterStateChangeReasonCode::INTERNAL_ERROR;
}
else if (hashCode == VALIDATION_ERROR_HASH)
{
return ClusterStateChangeReasonCode::VALIDATION_ERROR;
}
else if (hashCode == INSTANCE_FAILURE_HASH)
{
return ClusterStateChangeReasonCode::INSTANCE_FAILURE;
}
else if (hashCode == BOOTSTRAP_FAILURE_HASH)
{
return ClusterStateChangeReasonCode::BOOTSTRAP_FAILURE;
}
else if (hashCode == USER_REQUEST_HASH)
{
return ClusterStateChangeReasonCode::USER_REQUEST;
}
else if (hashCode == STEP_FAILURE_HASH)
{
return ClusterStateChangeReasonCode::STEP_FAILURE;
}
else if (hashCode == ALL_STEPS_COMPLETED_HASH)
{
return ClusterStateChangeReasonCode::ALL_STEPS_COMPLETED;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ClusterStateChangeReasonCode>(hashCode);
}
return ClusterStateChangeReasonCode::NOT_SET;
}
MessageSystemAttributeName GetMessageSystemAttributeNameForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == SenderId_HASH)
{
return MessageSystemAttributeName::SenderId;
}
else if (hashCode == SentTimestamp_HASH)
{
return MessageSystemAttributeName::SentTimestamp;
}
else if (hashCode == ApproximateReceiveCount_HASH)
{
return MessageSystemAttributeName::ApproximateReceiveCount;
}
else if (hashCode == ApproximateFirstReceiveTimestamp_HASH)
{
return MessageSystemAttributeName::ApproximateFirstReceiveTimestamp;
}
else if (hashCode == SequenceNumber_HASH)
{
return MessageSystemAttributeName::SequenceNumber;
}
else if (hashCode == MessageDeduplicationId_HASH)
{
return MessageSystemAttributeName::MessageDeduplicationId;
}
else if (hashCode == MessageGroupId_HASH)
{
return MessageSystemAttributeName::MessageGroupId;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<MessageSystemAttributeName>(hashCode);
}
return MessageSystemAttributeName::NOT_SET;
}
ImageAttributeName GetImageAttributeNameForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == description_HASH)
{
return ImageAttributeName::description;
}
else if (hashCode == kernel_HASH)
{
return ImageAttributeName::kernel;
}
else if (hashCode == ramdisk_HASH)
{
return ImageAttributeName::ramdisk;
}
else if (hashCode == launchPermission_HASH)
{
return ImageAttributeName::launchPermission;
}
else if (hashCode == productCodes_HASH)
{
return ImageAttributeName::productCodes;
}
else if (hashCode == blockDeviceMapping_HASH)
{
return ImageAttributeName::blockDeviceMapping;
}
else if (hashCode == sriovNetSupport_HASH)
{
return ImageAttributeName::sriovNetSupport;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ImageAttributeName>(hashCode);
}
return ImageAttributeName::NOT_SET;
}
PolicySourceType GetPolicySourceTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == user_HASH)
{
return PolicySourceType::user;
}
else if (hashCode == group_HASH)
{
return PolicySourceType::group;
}
else if (hashCode == role_HASH)
{
return PolicySourceType::role;
}
else if (hashCode == aws_managed_HASH)
{
return PolicySourceType::aws_managed;
}
else if (hashCode == user_managed_HASH)
{
return PolicySourceType::user_managed;
}
else if (hashCode == resource_HASH)
{
return PolicySourceType::resource;
}
else if (hashCode == none_HASH)
{
return PolicySourceType::none;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<PolicySourceType>(hashCode);
}
return PolicySourceType::NOT_SET;
}
ExecutionResult GetExecutionResultForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == PENDING_HASH)
{
return ExecutionResult::PENDING;
}
else if (hashCode == PASSED_HASH)
{
return ExecutionResult::PASSED;
}
else if (hashCode == WARNED_HASH)
{
return ExecutionResult::WARNED;
}
else if (hashCode == FAILED_HASH)
{
return ExecutionResult::FAILED;
}
else if (hashCode == SKIPPED_HASH)
{
return ExecutionResult::SKIPPED;
}
else if (hashCode == ERRORED_HASH)
{
return ExecutionResult::ERRORED;
}
else if (hashCode == STOPPED_HASH)
{
return ExecutionResult::STOPPED;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ExecutionResult>(hashCode);
}
return ExecutionResult::NOT_SET;
}
