C++ (Cpp) String Examples

Example #1

File: BundleTaskState.cpp Project: Fahrenheit2539/aws-sdk-cpp

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

Example #2

File: Method.cpp Project: capeanalytics/aws-sdk-cpp

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

Example #3

File: ImageState.cpp Project: Fahrenheit2539/aws-sdk-cpp

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

Example #4

File: PolicySourceType.cpp Project: yamashi/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;
}

Example #5

File: CertificateStatus.cpp Project: capeanalytics/aws-sdk-cpp

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

Example #6

File: JobStatus.cpp Project: Bu11etmagnet/aws-sdk-cpp

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

Example #7

File: AppType.cpp Project: Fahrenheit2539/aws-sdk-cpp

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

Example #8

File: FleetStateCode.cpp Project: marcomagdy/aws-sdk-cpp

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

Example #9

File: StepExecutionState.cpp Project: Fahrenheit2539/aws-sdk-cpp

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

Example #10

File: ClusterState.cpp Project: gedikli/aws-sdk-cpp

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

Example #11

File: JobFlowExecutionState.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #12

File: InstanceGroupStateChangeReasonCode.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #13

File: State.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #14

File: ReplicationStatus.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #15

File: Platform.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #16

File: StreamStatus.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #17

File: StatusType.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #18

File: VolumeAttachmentState.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #19

File: SourceType.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #20

File: AppAttributesKeys.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #21

File: LifeCycleState.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #22

File: StreamViewType.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #23

File: MonitoringState.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #24

File: NetworkInterfaceStatus.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #25

File: AWSAuthSigner.cpp Project: patilarpith/aws-sdk-cpp

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

Example #26

File: ConversionTaskState.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #27

File: CancelBatchErrorCode.cpp Project: wrtcoder/aws-sdk-cpp

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

Example #28

File: SourceType.cpp Project: Fahrenheit2539/aws-sdk-cpp

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

Example #29

File: WafActionType.cpp Project: capeanalytics/aws-sdk-cpp

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

Example #30

File: BucketLogsPermission.cpp Project: Fahrenheit2539/aws-sdk-cpp

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