C++ aws::String类代码示例

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