BundleTaskState GetBundleTaskStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == pending_HASH)
{
return BundleTaskState::pending;
}
else if (hashCode == waiting_for_shutdown_HASH)
{
return BundleTaskState::waiting_for_shutdown;
}
else if (hashCode == bundling_HASH)
{
return BundleTaskState::bundling;
}
else if (hashCode == storing_HASH)
{
return BundleTaskState::storing;
}
else if (hashCode == cancelling_HASH)
{
return BundleTaskState::cancelling;
}
else if (hashCode == complete_HASH)
{
return BundleTaskState::complete;
}
else if (hashCode == failed_HASH)
{
return BundleTaskState::failed;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<BundleTaskState>(hashCode);
}
return BundleTaskState::NOT_SET;
}
Method GetMethodForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == GET__HASH)
{
return Method::GET_;
}
else if (hashCode == HEAD_HASH)
{
return Method::HEAD;
}
else if (hashCode == POST_HASH)
{
return Method::POST;
}
else if (hashCode == PUT_HASH)
{
return Method::PUT;
}
else if (hashCode == PATCH_HASH)
{
return Method::PATCH;
}
else if (hashCode == OPTIONS_HASH)
{
return Method::OPTIONS;
}
else if (hashCode == DELETE__HASH)
{
return Method::DELETE_;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<Method>(hashCode);
}
return Method::NOT_SET;
}
ImageState GetImageStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == pending_HASH)
{
return ImageState::pending;
}
else if (hashCode == available_HASH)
{
return ImageState::available;
}
else if (hashCode == invalid_HASH)
{
return ImageState::invalid;
}
else if (hashCode == deregistered_HASH)
{
return ImageState::deregistered;
}
else if (hashCode == transient_HASH)
{
return ImageState::transient;
}
else if (hashCode == failed_HASH)
{
return ImageState::failed;
}
else if (hashCode == error_HASH)
{
return ImageState::error;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ImageState>(hashCode);
}
return ImageState::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;
}
CertificateStatus GetCertificateStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == PENDING_VALIDATION_HASH)
{
return CertificateStatus::PENDING_VALIDATION;
}
else if (hashCode == ISSUED_HASH)
{
return CertificateStatus::ISSUED;
}
else if (hashCode == INACTIVE_HASH)
{
return CertificateStatus::INACTIVE;
}
else if (hashCode == EXPIRED_HASH)
{
return CertificateStatus::EXPIRED;
}
else if (hashCode == VALIDATION_TIMED_OUT_HASH)
{
return CertificateStatus::VALIDATION_TIMED_OUT;
}
else if (hashCode == REVOKED_HASH)
{
return CertificateStatus::REVOKED;
}
else if (hashCode == FAILED_HASH)
{
return CertificateStatus::FAILED;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<CertificateStatus>(hashCode);
}
return CertificateStatus::NOT_SET;
}
JobStatus GetJobStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == Created_HASH)
{
return JobStatus::Created;
}
else if (hashCode == Queued_HASH)
{
return JobStatus::Queued;
}
else if (hashCode == Dispatched_HASH)
{
return JobStatus::Dispatched;
}
else if (hashCode == InProgress_HASH)
{
return JobStatus::InProgress;
}
else if (hashCode == TimedOut_HASH)
{
return JobStatus::TimedOut;
}
else if (hashCode == Succeeded_HASH)
{
return JobStatus::Succeeded;
}
else if (hashCode == Failed_HASH)
{
return JobStatus::Failed;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<JobStatus>(hashCode);
}
return JobStatus::NOT_SET;
}
AppType GetAppTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == aws_flow_ruby_HASH)
{
return AppType::aws_flow_ruby;
}
else if (hashCode == java_HASH)
{
return AppType::java;
}
else if (hashCode == rails_HASH)
{
return AppType::rails;
}
else if (hashCode == php_HASH)
{
return AppType::php;
}
else if (hashCode == nodejs_HASH)
{
return AppType::nodejs;
}
else if (hashCode == static__HASH)
{
return AppType::static_;
}
else if (hashCode == other_HASH)
{
return AppType::other;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<AppType>(hashCode);
}
return AppType::NOT_SET;
}
FleetStateCode GetFleetStateCodeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == submitted_HASH)
{
return FleetStateCode::submitted;
}
else if (hashCode == active_HASH)
{
return FleetStateCode::active;
}
else if (hashCode == deleted_HASH)
{
return FleetStateCode::deleted;
}
else if (hashCode == failed_HASH)
{
return FleetStateCode::failed;
}
else if (hashCode == deleted_running_HASH)
{
return FleetStateCode::deleted_running;
}
else if (hashCode == deleted_terminating_HASH)
{
return FleetStateCode::deleted_terminating;
}
else if (hashCode == modifying_HASH)
{
return FleetStateCode::modifying;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<FleetStateCode>(hashCode);
}
return FleetStateCode::NOT_SET;
}
StepExecutionState GetStepExecutionStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == PENDING_HASH)
{
return StepExecutionState::PENDING;
}
else if (hashCode == RUNNING_HASH)
{
return StepExecutionState::RUNNING;
}
else if (hashCode == CONTINUE_HASH)
{
return StepExecutionState::CONTINUE;
}
else if (hashCode == COMPLETED_HASH)
{
return StepExecutionState::COMPLETED;
}
else if (hashCode == CANCELLED_HASH)
{
return StepExecutionState::CANCELLED;
}
else if (hashCode == FAILED_HASH)
{
return StepExecutionState::FAILED;
}
else if (hashCode == INTERRUPTED_HASH)
{
return StepExecutionState::INTERRUPTED;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<StepExecutionState>(hashCode);
}
return StepExecutionState::NOT_SET;
}
ClusterState GetClusterStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == STARTING_HASH)
{
return ClusterState::STARTING;
}
else if (hashCode == BOOTSTRAPPING_HASH)
{
return ClusterState::BOOTSTRAPPING;
}
else if (hashCode == RUNNING_HASH)
{
return ClusterState::RUNNING;
}
else if (hashCode == WAITING_HASH)
{
return ClusterState::WAITING;
}
else if (hashCode == TERMINATING_HASH)
{
return ClusterState::TERMINATING;
}
else if (hashCode == TERMINATED_HASH)
{
return ClusterState::TERMINATED;
}
else if (hashCode == TERMINATED_WITH_ERRORS_HASH)
{
return ClusterState::TERMINATED_WITH_ERRORS;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<ClusterState>(hashCode);
}
return ClusterState::NOT_SET;
}
JobFlowExecutionState GetJobFlowExecutionStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == STARTING_HASH)
{
return JobFlowExecutionState::STARTING;
}
else if (hashCode == BOOTSTRAPPING_HASH)
{
return JobFlowExecutionState::BOOTSTRAPPING;
}
else if (hashCode == RUNNING_HASH)
{
return JobFlowExecutionState::RUNNING;
}
else if (hashCode == WAITING_HASH)
{
return JobFlowExecutionState::WAITING;
}
else if (hashCode == SHUTTING_DOWN_HASH)
{
return JobFlowExecutionState::SHUTTING_DOWN;
}
else if (hashCode == TERMINATED_HASH)
{
return JobFlowExecutionState::TERMINATED;
}
else if (hashCode == COMPLETED_HASH)
{
return JobFlowExecutionState::COMPLETED;
}
else if (hashCode == FAILED_HASH)
{
return JobFlowExecutionState::FAILED;
}
return JobFlowExecutionState::NOT_SET;
}
InstanceGroupStateChangeReasonCode GetInstanceGroupStateChangeReasonCodeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == INTERNAL_ERROR_HASH)
{
return InstanceGroupStateChangeReasonCode::INTERNAL_ERROR;
}
else if (hashCode == VALIDATION_ERROR_HASH)
{
return InstanceGroupStateChangeReasonCode::VALIDATION_ERROR;
}
else if (hashCode == INSTANCE_FAILURE_HASH)
{
return InstanceGroupStateChangeReasonCode::INSTANCE_FAILURE;
}
else if (hashCode == CLUSTER_TERMINATED_HASH)
{
return InstanceGroupStateChangeReasonCode::CLUSTER_TERMINATED;
}
return InstanceGroupStateChangeReasonCode::NOT_SET;
}
State GetStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == Pending_HASH)
{
return State::Pending;
}
else if (hashCode == Available_HASH)
{
return State::Available;
}
else if (hashCode == Deleting_HASH)
{
return State::Deleting;
}
else if (hashCode == Deleted_HASH)
{
return State::Deleted;
}
return State::NOT_SET;
}
ReplicationStatus GetReplicationStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == COMPLETE_HASH)
{
return ReplicationStatus::COMPLETE;
}
else if (hashCode == PENDING_HASH)
{
return ReplicationStatus::PENDING;
}
else if (hashCode == FAILED_HASH)
{
return ReplicationStatus::FAILED;
}
else if (hashCode == REPLICA_HASH)
{
return ReplicationStatus::REPLICA;
}
return ReplicationStatus::NOT_SET;
}
Platform GetPlatformForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == APNS_HASH)
{
return Platform::APNS;
}
else if (hashCode == APNS_SANDBOX_HASH)
{
return Platform::APNS_SANDBOX;
}
else if (hashCode == GCM_HASH)
{
return Platform::GCM;
}
else if (hashCode == ADM_HASH)
{
return Platform::ADM;
}
return Platform::NOT_SET;
}
StreamStatus GetStreamStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == CREATING_HASH)
{
return StreamStatus::CREATING;
}
else if (hashCode == DELETING_HASH)
{
return StreamStatus::DELETING;
}
else if (hashCode == ACTIVE_HASH)
{
return StreamStatus::ACTIVE;
}
else if (hashCode == UPDATING_HASH)
{
return StreamStatus::UPDATING;
}
return StreamStatus::NOT_SET;
}
StatusType GetStatusTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == passed_HASH)
{
return StatusType::passed;
}
else if (hashCode == failed_HASH)
{
return StatusType::failed;
}
else if (hashCode == insufficient_data_HASH)
{
return StatusType::insufficient_data;
}
else if (hashCode == initializing_HASH)
{
return StatusType::initializing;
}
return StatusType::NOT_SET;
}
VolumeAttachmentState GetVolumeAttachmentStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == attaching_HASH)
{
return VolumeAttachmentState::attaching;
}
else if (hashCode == attached_HASH)
{
return VolumeAttachmentState::attached;
}
else if (hashCode == detaching_HASH)
{
return VolumeAttachmentState::detaching;
}
else if (hashCode == detached_HASH)
{
return VolumeAttachmentState::detached;
}
return VolumeAttachmentState::NOT_SET;
}
SourceType GetSourceTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == cluster_HASH)
{
return SourceType::cluster;
}
else if (hashCode == cluster_parameter_group_HASH)
{
return SourceType::cluster_parameter_group;
}
else if (hashCode == cluster_security_group_HASH)
{
return SourceType::cluster_security_group;
}
else if (hashCode == cluster_snapshot_HASH)
{
return SourceType::cluster_snapshot;
}
return SourceType::NOT_SET;
}
AppAttributesKeys GetAppAttributesKeysForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == DocumentRoot_HASH)
{
return AppAttributesKeys::DocumentRoot;
}
else if (hashCode == RailsEnv_HASH)
{
return AppAttributesKeys::RailsEnv;
}
else if (hashCode == AutoBundleOnDeploy_HASH)
{
return AppAttributesKeys::AutoBundleOnDeploy;
}
else if (hashCode == AwsFlowRubySettings_HASH)
{
return AppAttributesKeys::AwsFlowRubySettings;
}
return AppAttributesKeys::NOT_SET;
}
LifeCycleState GetLifeCycleStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == creating_HASH)
{
return LifeCycleState::creating;
}
else if (hashCode == available_HASH)
{
return LifeCycleState::available;
}
else if (hashCode == deleting_HASH)
{
return LifeCycleState::deleting;
}
else if (hashCode == deleted_HASH)
{
return LifeCycleState::deleted;
}
return LifeCycleState::NOT_SET;
}
StreamViewType GetStreamViewTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == NEW_IMAGE_HASH)
{
return StreamViewType::NEW_IMAGE;
}
else if (hashCode == OLD_IMAGE_HASH)
{
return StreamViewType::OLD_IMAGE;
}
else if (hashCode == NEW_AND_OLD_IMAGES_HASH)
{
return StreamViewType::NEW_AND_OLD_IMAGES;
}
else if (hashCode == KEYS_ONLY_HASH)
{
return StreamViewType::KEYS_ONLY;
}
return StreamViewType::NOT_SET;
}
MonitoringState GetMonitoringStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == disabled_HASH)
{
return MonitoringState::disabled;
}
else if (hashCode == disabling_HASH)
{
return MonitoringState::disabling;
}
else if (hashCode == enabled_HASH)
{
return MonitoringState::enabled;
}
else if (hashCode == pending_HASH)
{
return MonitoringState::pending;
}
return MonitoringState::NOT_SET;
}
NetworkInterfaceStatus GetNetworkInterfaceStatusForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == available_HASH)
{
return NetworkInterfaceStatus::available;
}
else if (hashCode == attaching_HASH)
{
return NetworkInterfaceStatus::attaching;
}
else if (hashCode == in_use_HASH)
{
return NetworkInterfaceStatus::in_use;
}
else if (hashCode == detaching_HASH)
{
return NetworkInterfaceStatus::detaching;
}
return NetworkInterfaceStatus::NOT_SET;
}
Aws::String AWSAuthV4Signer::GenerateSignature(const AWSCredentials& credentials, const Aws::String& stringToSign, const Aws::String& simpleDate) const
{
AWS_LOGSTREAM_DEBUG(v4LogTag, "Final String to sign: " << stringToSign);
Aws::StringStream ss;
auto& partialSignature = ComputeLongLivedHash(credentials.GetAWSSecretKey(), simpleDate);
auto hashResult = m_HMAC->Calculate(ByteBuffer((unsigned char*)stringToSign.c_str(), stringToSign.length()), partialSignature);
if (!hashResult.IsSuccess())
{
AWS_LOGSTREAM_ERROR(v4LogTag, "Unable to hmac (sha256) final string \"" << stringToSign << "\"");
return "";
}
//now we finally sign our request string with our hex encoded derived hash.
auto finalSigningDigest = hashResult.GetResult();
auto finalSigningHash = HashingUtils::HexEncode(finalSigningDigest);
AWS_LOGSTREAM_DEBUG(v4LogTag, "Final computed signing hash: " << finalSigningHash);
return finalSigningHash;
}
ConversionTaskState GetConversionTaskStateForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == active_HASH)
{
return ConversionTaskState::active;
}
else if (hashCode == cancelling_HASH)
{
return ConversionTaskState::cancelling;
}
else if (hashCode == cancelled_HASH)
{
return ConversionTaskState::cancelled;
}
else if (hashCode == completed_HASH)
{
return ConversionTaskState::completed;
}
return ConversionTaskState::NOT_SET;
}
CancelBatchErrorCode GetCancelBatchErrorCodeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == fleetRequestIdDoesNotExist_HASH)
{
return CancelBatchErrorCode::fleetRequestIdDoesNotExist;
}
else if (hashCode == fleetRequestIdMalformed_HASH)
{
return CancelBatchErrorCode::fleetRequestIdMalformed;
}
else if (hashCode == fleetRequestNotInCancellableState_HASH)
{
return CancelBatchErrorCode::fleetRequestNotInCancellableState;
}
else if (hashCode == unexpectedError_HASH)
{
return CancelBatchErrorCode::unexpectedError;
}
return CancelBatchErrorCode::NOT_SET;
}
SourceType GetSourceTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == db_instance_HASH)
{
return SourceType::db_instance;
}
else if (hashCode == db_parameter_group_HASH)
{
return SourceType::db_parameter_group;
}
else if (hashCode == db_security_group_HASH)
{
return SourceType::db_security_group;
}
else if (hashCode == db_snapshot_HASH)
{
return SourceType::db_snapshot;
}
else if (hashCode == db_cluster_HASH)
{
return SourceType::db_cluster;
}
else if (hashCode == db_cluster_snapshot_HASH)
{
return SourceType::db_cluster_snapshot;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<SourceType>(hashCode);
}
return SourceType::NOT_SET;
}
WafActionType GetWafActionTypeForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == BLOCK_HASH)
{
return WafActionType::BLOCK;
}
else if (hashCode == ALLOW_HASH)
{
return WafActionType::ALLOW;
}
else if (hashCode == COUNT_HASH)
{
return WafActionType::COUNT;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<WafActionType>(hashCode);
}
return WafActionType::NOT_SET;
}
BucketLogsPermission GetBucketLogsPermissionForName(const Aws::String& name)
{
int hashCode = HashingUtils::HashString(name.c_str());
if (hashCode == FULL_CONTROL_HASH)
{
return BucketLogsPermission::FULL_CONTROL;
}
else if (hashCode == READ_HASH)
{
return BucketLogsPermission::READ;
}
else if (hashCode == WRITE_HASH)
{
return BucketLogsPermission::WRITE;
}
EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
if(overflowContainer)
{
overflowContainer->StoreOverflow(hashCode, name);
return static_cast<BucketLogsPermission>(hashCode);
}
return BucketLogsPermission::NOT_SET;
}