Ejemplos de String::c_str en C++ (Cpp)

Ejemplo n.º 1

Archivo: ArtifactPackaging.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 2

Archivo: Owner.cpp Proyecto: gedikli/aws-sdk-cpp

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;
}

Ejemplo n.º 3

Archivo: SortOrder.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 4

Archivo: ExpirationStatus.cpp Proyecto: Bu11etmagnet/aws-sdk-cpp

        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;
        }

Ejemplo n.º 5

Archivo: OrderEnum.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 6

Archivo: ContentHandlingStrategy.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 7

Archivo: RootDeviceType.cpp Proyecto: Fahrenheit2539/aws-sdk-cpp

        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;
        }

Ejemplo n.º 8

Archivo: TagResourceType.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 9

Archivo: MarketType.cpp Proyecto: Bu11etmagnet/aws-sdk-cpp

        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;
        }

Ejemplo n.º 10

Archivo: LogType.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 11

Archivo: KeyType.cpp Proyecto: Bu11etmagnet/aws-sdk-cpp

        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;
        }

Ejemplo n.º 12

Archivo: AccessDirection.cpp Proyecto: chadbrewbaker/aws-sdk-cpp

        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;
        }

Ejemplo n.º 13

Archivo: ResourceRecordSetFailover.cpp Proyecto: yamashi/aws-sdk-cpp

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;
}

Ejemplo n.º 14

Archivo: TlsPolicy.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 15

Archivo: ConfigRuleComplianceSummaryGroupKey.cpp Proyecto: marcomagdy/aws-sdk-cpp

        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;
        }

Ejemplo n.º 16

Archivo: TemplateStage.cpp Proyecto: jliang1010/aws-sdk-cpp

        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;
        }

Ejemplo n.º 17

Archivo: Payer.cpp Proyecto: Bu11etmagnet/aws-sdk-cpp

        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;
        }

Ejemplo n.º 18

Archivo: RoutingStrategyType.cpp Proyecto: chadbrewbaker/aws-sdk-cpp

        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;
        }

Ejemplo n.º 19

Archivo: DeploymentReadyAction.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 20

Archivo: ContinuousBackupsStatus.cpp Proyecto: marcomagdy/aws-sdk-cpp

        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;
        }

Ejemplo n.º 21

Archivo: ValidationSeverity.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 22

Archivo: ContentType.cpp Proyecto: jliang1010/aws-sdk-cpp

        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;
        }

Ejemplo n.º 23

Archivo: ConsistencyLevel.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 24

Archivo: GameLiftEndpoint.cpp Proyecto: chadbrewbaker/aws-sdk-cpp

  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();
  }

Ejemplo n.º 25

Archivo: CognitoIdentityProviderEndpoint.cpp Proyecto: marcomagdy/aws-sdk-cpp

  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();
  }

Ejemplo n.º 26

Archivo: ClusterStateChangeReasonCode.cpp Proyecto: chadbrewbaker/aws-sdk-cpp

        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;
        }

Ejemplo n.º 27

Archivo: MessageSystemAttributeName.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 28

Archivo: ImageAttributeName.cpp Proyecto: Bu11etmagnet/aws-sdk-cpp

        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;
        }

Ejemplo n.º 29

Archivo: PolicySourceType.cpp Proyecto: capeanalytics/aws-sdk-cpp

        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;
        }

Ejemplo n.º 30

Archivo: ExecutionResult.cpp Proyecto: Bu11etmagnet/aws-sdk-cpp

        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;
        }