MessageType GetMessageTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == ConfigurationItemChangeNotification_HASH)
          {
            return MessageType::ConfigurationItemChangeNotification;
          }
          else if (hashCode == ConfigurationSnapshotDeliveryCompleted_HASH)
          {
            return MessageType::ConfigurationSnapshotDeliveryCompleted;
          }
          else if (hashCode == ScheduledNotification_HASH)
          {
            return MessageType::ScheduledNotification;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<MessageType>(hashCode);
          }

          return MessageType::NOT_SET;
        }
        ChannelType GetChannelTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Facebook_HASH)
          {
            return ChannelType::Facebook;
          }
          else if (hashCode == Slack_HASH)
          {
            return ChannelType::Slack;
          }
          else if (hashCode == Twilio_Sms_HASH)
          {
            return ChannelType::Twilio_Sms;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ChannelType>(hashCode);
          }

          return ChannelType::NOT_SET;
        }
        ArtifactCategory GetArtifactCategoryForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == SCREENSHOT_HASH)
          {
            return ArtifactCategory::SCREENSHOT;
          }
          else if (hashCode == FILE_HASH)
          {
            return ArtifactCategory::FILE;
          }
          else if (hashCode == LOG_HASH)
          {
            return ArtifactCategory::LOG;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ArtifactCategory>(hashCode);
          }

          return ArtifactCategory::NOT_SET;
        }
        BundleType GetBundleTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == tar_HASH)
          {
            return BundleType::tar;
          }
          else if (hashCode == tgz_HASH)
          {
            return BundleType::tgz;
          }
          else if (hashCode == zip_HASH)
          {
            return BundleType::zip;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<BundleType>(hashCode);
          }

          return BundleType::NOT_SET;
        }
        RouteOrigin GetRouteOriginForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == CreateRouteTable_HASH)
          {
            return RouteOrigin::CreateRouteTable;
          }
          else if (hashCode == CreateRoute_HASH)
          {
            return RouteOrigin::CreateRoute;
          }
          else if (hashCode == EnableVgwRoutePropagation_HASH)
          {
            return RouteOrigin::EnableVgwRoutePropagation;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<RouteOrigin>(hashCode);
          }

          return RouteOrigin::NOT_SET;
        }
Exemple #6
0
Fault GetFaultForName(const Aws::String& name)
{
    int hashCode = HashingUtils::HashString(name.c_str());
    if (hashCode == Client_HASH)
    {
        return Fault::Client;
    }
    else if (hashCode == Server_HASH)
    {
        return Fault::Server;
    }
    else if (hashCode == Unknown_HASH)
    {
        return Fault::Unknown;
    }
    EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
    if(overflowContainer)
    {
        overflowContainer->StoreOverflow(hashCode, name);
        return static_cast<Fault>(hashCode);
    }

    return Fault::NOT_SET;
}
        OAuthFlowType GetOAuthFlowTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == code_HASH)
          {
            return OAuthFlowType::code;
          }
          else if (hashCode == implicit_HASH)
          {
            return OAuthFlowType::implicit;
          }
          else if (hashCode == client_credentials_HASH)
          {
            return OAuthFlowType::client_credentials;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<OAuthFlowType>(hashCode);
          }

          return OAuthFlowType::NOT_SET;
        }
Exemple #8
0
        MetricName GetMetricNameForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == ActivatingGameSessions_HASH)
          {
            return MetricName::ActivatingGameSessions;
          }
          else if (hashCode == ActiveGameSessions_HASH)
          {
            return MetricName::ActiveGameSessions;
          }
          else if (hashCode == ActiveInstances_HASH)
          {
            return MetricName::ActiveInstances;
          }
          else if (hashCode == AvailablePlayerSessions_HASH)
          {
            return MetricName::AvailablePlayerSessions;
          }
          else if (hashCode == CurrentPlayerSessions_HASH)
          {
            return MetricName::CurrentPlayerSessions;
          }
          else if (hashCode == IdleInstances_HASH)
          {
            return MetricName::IdleInstances;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<MetricName>(hashCode);
          }

          return MetricName::NOT_SET;
        }
        Compute GetComputeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == VALUE_HASH)
          {
            return Compute::VALUE;
          }
          else if (hashCode == STANDARD_HASH)
          {
            return Compute::STANDARD;
          }
          else if (hashCode == PERFORMANCE_HASH)
          {
            return Compute::PERFORMANCE;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<Compute>(hashCode);
          }

          return Compute::NOT_SET;
        }
        ActionConfigurationPropertyType GetActionConfigurationPropertyTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == String_HASH)
          {
            return ActionConfigurationPropertyType::String;
          }
          else if (hashCode == Number_HASH)
          {
            return ActionConfigurationPropertyType::Number;
          }
          else if (hashCode == Boolean_HASH)
          {
            return ActionConfigurationPropertyType::Boolean;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ActionConfigurationPropertyType>(hashCode);
          }

          return ActionConfigurationPropertyType::NOT_SET;
        }
        ComputeType GetComputeTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == BUILD_GENERAL1_SMALL_HASH)
          {
            return ComputeType::BUILD_GENERAL1_SMALL;
          }
          else if (hashCode == BUILD_GENERAL1_MEDIUM_HASH)
          {
            return ComputeType::BUILD_GENERAL1_MEDIUM;
          }
          else if (hashCode == BUILD_GENERAL1_LARGE_HASH)
          {
            return ComputeType::BUILD_GENERAL1_LARGE;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ComputeType>(hashCode);
          }

          return ComputeType::NOT_SET;
        }
        LanguageCode GetLanguageCodeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == en_HASH)
          {
            return LanguageCode::en;
          }
          else if (hashCode == es_HASH)
          {
            return LanguageCode::es;
          }
          else if (hashCode == fr_HASH)
          {
            return LanguageCode::fr;
          }
          else if (hashCode == de_HASH)
          {
            return LanguageCode::de;
          }
          else if (hashCode == it_HASH)
          {
            return LanguageCode::it;
          }
          else if (hashCode == pt_HASH)
          {
            return LanguageCode::pt;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<LanguageCode>(hashCode);
          }

          return LanguageCode::NOT_SET;
        }
        ProjectSortByType GetProjectSortByTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == NAME_HASH)
          {
            return ProjectSortByType::NAME;
          }
          else if (hashCode == CREATED_TIME_HASH)
          {
            return ProjectSortByType::CREATED_TIME;
          }
          else if (hashCode == LAST_MODIFIED_TIME_HASH)
          {
            return ProjectSortByType::LAST_MODIFIED_TIME;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ProjectSortByType>(hashCode);
          }

          return ProjectSortByType::NOT_SET;
        }
        CloudHsmObjectState GetCloudHsmObjectStateForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == READY_HASH)
          {
            return CloudHsmObjectState::READY;
          }
          else if (hashCode == UPDATING_HASH)
          {
            return CloudHsmObjectState::UPDATING;
          }
          else if (hashCode == DEGRADED_HASH)
          {
            return CloudHsmObjectState::DEGRADED;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<CloudHsmObjectState>(hashCode);
          }

          return CloudHsmObjectState::NOT_SET;
        }
        ChangeTokenStatus GetChangeTokenStatusForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == PROVISIONED_HASH)
          {
            return ChangeTokenStatus::PROVISIONED;
          }
          else if (hashCode == PENDING_HASH)
          {
            return ChangeTokenStatus::PENDING;
          }
          else if (hashCode == INSYNC_HASH)
          {
            return ChangeTokenStatus::INSYNC;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ChangeTokenStatus>(hashCode);
          }

          return ChangeTokenStatus::NOT_SET;
        }
        GeoRestrictionType GetGeoRestrictionTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == blacklist_HASH)
          {
            return GeoRestrictionType::blacklist;
          }
          else if (hashCode == whitelist_HASH)
          {
            return GeoRestrictionType::whitelist;
          }
          else if (hashCode == none_HASH)
          {
            return GeoRestrictionType::none;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<GeoRestrictionType>(hashCode);
          }

          return GeoRestrictionType::NOT_SET;
        }
        ResourceAttribute GetResourceAttributeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Properties_HASH)
          {
            return ResourceAttribute::Properties;
          }
          else if (hashCode == Metadata_HASH)
          {
            return ResourceAttribute::Metadata;
          }
          else if (hashCode == CreationPolicy_HASH)
          {
            return ResourceAttribute::CreationPolicy;
          }
          else if (hashCode == UpdatePolicy_HASH)
          {
            return ResourceAttribute::UpdatePolicy;
          }
          else if (hashCode == DeletionPolicy_HASH)
          {
            return ResourceAttribute::DeletionPolicy;
          }
          else if (hashCode == Tags_HASH)
          {
            return ResourceAttribute::Tags;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ResourceAttribute>(hashCode);
          }

          return ResourceAttribute::NOT_SET;
        }
        VolumeType GetVolumeTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == gp2_HASH)
          {
            return VolumeType::gp2;
          }
          else if (hashCode == io1_HASH)
          {
            return VolumeType::io1;
          }
          else if (hashCode == standard_HASH)
          {
            return VolumeType::standard;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<VolumeType>(hashCode);
          }

          return VolumeType::NOT_SET;
        }
        ParametersFilterKey GetParametersFilterKeyForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Name_HASH)
          {
            return ParametersFilterKey::Name;
          }
          else if (hashCode == Type_HASH)
          {
            return ParametersFilterKey::Type;
          }
          else if (hashCode == KeyId_HASH)
          {
            return ParametersFilterKey::KeyId;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ParametersFilterKey>(hashCode);
          }

          return ParametersFilterKey::NOT_SET;
        }
        IpRouteStatusMsg GetIpRouteStatusMsgForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Adding_HASH)
          {
            return IpRouteStatusMsg::Adding;
          }
          else if (hashCode == Added_HASH)
          {
            return IpRouteStatusMsg::Added;
          }
          else if (hashCode == Removing_HASH)
          {
            return IpRouteStatusMsg::Removing;
          }
          else if (hashCode == Removed_HASH)
          {
            return IpRouteStatusMsg::Removed;
          }
          else if (hashCode == AddFailed_HASH)
          {
            return IpRouteStatusMsg::AddFailed;
          }
          else if (hashCode == RemoveFailed_HASH)
          {
            return IpRouteStatusMsg::RemoveFailed;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<IpRouteStatusMsg>(hashCode);
          }

          return IpRouteStatusMsg::NOT_SET;
        }
        AssociationStatusName GetAssociationStatusNameForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Pending_HASH)
          {
            return AssociationStatusName::Pending;
          }
          else if (hashCode == Success_HASH)
          {
            return AssociationStatusName::Success;
          }
          else if (hashCode == Failed_HASH)
          {
            return AssociationStatusName::Failed;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<AssociationStatusName>(hashCode);
          }

          return AssociationStatusName::NOT_SET;
        }
        IsModifiable GetIsModifiableForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == TRUE_HASH)
          {
            return IsModifiable::TRUE;
          }
          else if (hashCode == FALSE_HASH)
          {
            return IsModifiable::FALSE;
          }
          else if (hashCode == CONDITIONAL_HASH)
          {
            return IsModifiable::CONDITIONAL;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<IsModifiable>(hashCode);
          }

          return IsModifiable::NOT_SET;
        }
        InstanceFleetType GetInstanceFleetTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == MASTER_HASH)
          {
            return InstanceFleetType::MASTER;
          }
          else if (hashCode == CORE_HASH)
          {
            return InstanceFleetType::CORE;
          }
          else if (hashCode == TASK_HASH)
          {
            return InstanceFleetType::TASK;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<InstanceFleetType>(hashCode);
          }

          return InstanceFleetType::NOT_SET;
        }
SuggesterFuzzyMatching GetSuggesterFuzzyMatchingForName(const Aws::String& name)
{
    int hashCode = HashingUtils::HashString(name.c_str());
    if (hashCode == none_HASH)
    {
        return SuggesterFuzzyMatching::none;
    }
    else if (hashCode == low_HASH)
    {
        return SuggesterFuzzyMatching::low;
    }
    else if (hashCode == high_HASH)
    {
        return SuggesterFuzzyMatching::high;
    }
    EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
    if(overflowContainer)
    {
        overflowContainer->StoreOverflow(hashCode, name);
        return static_cast<SuggesterFuzzyMatching>(hashCode);
    }

    return SuggesterFuzzyMatching::NOT_SET;
}
AlgorithmSpec GetAlgorithmSpecForName(const Aws::String& name)
{
    int hashCode = HashingUtils::HashString(name.c_str());
    if (hashCode == RSAES_PKCS1_V1_5_HASH)
    {
        return AlgorithmSpec::RSAES_PKCS1_V1_5;
    }
    else if (hashCode == RSAES_OAEP_SHA_1_HASH)
    {
        return AlgorithmSpec::RSAES_OAEP_SHA_1;
    }
    else if (hashCode == RSAES_OAEP_SHA_256_HASH)
    {
        return AlgorithmSpec::RSAES_OAEP_SHA_256;
    }
    EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
    if(overflowContainer)
    {
        overflowContainer->StoreOverflow(hashCode, name);
        return static_cast<AlgorithmSpec>(hashCode);
    }

    return AlgorithmSpec::NOT_SET;
}
        ApplicationStatus GetApplicationStatusForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == DELETING_HASH)
          {
            return ApplicationStatus::DELETING;
          }
          else if (hashCode == STARTING_HASH)
          {
            return ApplicationStatus::STARTING;
          }
          else if (hashCode == STOPPING_HASH)
          {
            return ApplicationStatus::STOPPING;
          }
          else if (hashCode == READY_HASH)
          {
            return ApplicationStatus::READY;
          }
          else if (hashCode == RUNNING_HASH)
          {
            return ApplicationStatus::RUNNING;
          }
          else if (hashCode == UPDATING_HASH)
          {
            return ApplicationStatus::UPDATING;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ApplicationStatus>(hashCode);
          }

          return ApplicationStatus::NOT_SET;
        }
        ComparisonOperator GetComparisonOperatorForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == EQ_HASH)
          {
            return ComparisonOperator::EQ;
          }
          else if (hashCode == NE_HASH)
          {
            return ComparisonOperator::NE;
          }
          else if (hashCode == LE_HASH)
          {
            return ComparisonOperator::LE;
          }
          else if (hashCode == LT_HASH)
          {
            return ComparisonOperator::LT;
          }
          else if (hashCode == GE_HASH)
          {
            return ComparisonOperator::GE;
          }
          else if (hashCode == GT_HASH)
          {
            return ComparisonOperator::GT;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ComparisonOperator>(hashCode);
          }

          return ComparisonOperator::NOT_SET;
        }
        CommandFilterKey GetCommandFilterKeyForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == InvokedAfter_HASH)
          {
            return CommandFilterKey::InvokedAfter;
          }
          else if (hashCode == InvokedBefore_HASH)
          {
            return CommandFilterKey::InvokedBefore;
          }
          else if (hashCode == Status_HASH)
          {
            return CommandFilterKey::Status;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<CommandFilterKey>(hashCode);
          }

          return CommandFilterKey::NOT_SET;
        }
        CertificateStatus GetCertificateStatusForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == ACTIVE_HASH)
          {
            return CertificateStatus::ACTIVE;
          }
          else if (hashCode == INACTIVE_HASH)
          {
            return CertificateStatus::INACTIVE;
          }
          else if (hashCode == REVOKED_HASH)
          {
            return CertificateStatus::REVOKED;
          }
          else if (hashCode == PENDING_TRANSFER_HASH)
          {
            return CertificateStatus::PENDING_TRANSFER;
          }
          else if (hashCode == REGISTER_INACTIVE_HASH)
          {
            return CertificateStatus::REGISTER_INACTIVE;
          }
          else if (hashCode == PENDING_ACTIVATION_HASH)
          {
            return CertificateStatus::PENDING_ACTIVATION;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<CertificateStatus>(hashCode);
          }

          return CertificateStatus::NOT_SET;
        }
        LifecycleEventStatus GetLifecycleEventStatusForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Pending_HASH)
          {
            return LifecycleEventStatus::Pending;
          }
          else if (hashCode == InProgress_HASH)
          {
            return LifecycleEventStatus::InProgress;
          }
          else if (hashCode == Succeeded_HASH)
          {
            return LifecycleEventStatus::Succeeded;
          }
          else if (hashCode == Failed_HASH)
          {
            return LifecycleEventStatus::Failed;
          }
          else if (hashCode == Skipped_HASH)
          {
            return LifecycleEventStatus::Skipped;
          }
          else if (hashCode == Unknown_HASH)
          {
            return LifecycleEventStatus::Unknown;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<LifecycleEventStatus>(hashCode);
          }

          return LifecycleEventStatus::NOT_SET;
        }