Get the object to be used as the value of the HTTP request.

@param swaggerMethodArguments the method arguments to get the value object from
@return the object that will be used as the body of the HTTP request
321348
public Object body(Object[] swaggerMethodArguments) {
        Object result = null;

        if (bodyContentMethodParameterIndex != null
                && swaggerMethodArguments != null
                && 0 <= bodyContentMethodParameterIndex
                && bodyContentMethodParameterIndex < swaggerMethodArguments.length) {
            result = swaggerMethodArguments[bodyContentMethodParameterIndex];
        }

        if (formSubstitutions != null
                && !formSubstitutions.isEmpty()
                && swaggerMethodArguments != null) {
            result = formSubstitutions.stream()
                .map(s -> serializeFormData(s.urlParameterName(), swaggerMethodArguments[s.methodParameterIndex()]))
                .collect(Collectors.joining("&"));
        }

        return result;
    }
1100178
private Object[] getMethodArgumentValues(WampMessage message, Object... providedArgs)
			throws Exception {

		MethodParameter[] parameters = getMethodParameters();
		Object[] args = new Object[parameters.length];
		int argIndex = 0;
		for (int i = 0; i < parameters.length; i++) {
			MethodParameter parameter = parameters[i];
			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
			GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());

			if (this.argumentResolvers.supportsParameter(parameter)) {
				try {
					args[i] = this.argumentResolvers.resolveArgument(parameter, message);
					continue;
				}
				catch (Exception ex) {
					if (this.logger.isTraceEnabled()) {
						this.logger.trace(getArgumentResolutionErrorMessage(
								"Error resolving argument", i), ex);
					}
					throw ex;
				}
			}

			if (providedArgs != null) {
				args[i] = this.methodParameterConverter.convert(parameter,
						providedArgs[argIndex]);
				if (args[i] != null) {
					argIndex++;
					continue;
				}
			}

			if (args[i] == null) {
				String error = getArgumentResolutionErrorMessage(
						"No suitable resolver for argument", i);
				throw new IllegalStateException(error);
			}
		}
		return args;
	}
1025820
public static WebApplicationService getService(final List<ArgumentExtractor> argumentExtractors, final RequestContext context) {
        val request = WebUtils.getHttpServletRequestFromExternalWebflowContext(context);
        return HttpRequestUtils.getService(argumentExtractors, request);
    }
368872
public static <T> HttpMethod retrieveMethod(Request<T> request) {
		if (request == null) {
			return null;
		}

		Class<?> clazz = request.getClass();

		Method method = clazz.getAnnotation(Method.class);
		HttpMethod httpMethod = method.value();
		return httpMethod;
	}
9539
public HttpRequest setRequestMethod(String requestMethod) {
    Preconditions.checkArgument(requestMethod == null || HttpMediaType.matchesToken(requestMethod));
    this.requestMethod = requestMethod;
    return this;
  }
4957
private String getHttpMethod(final HttpServletRequest request) {
        String ret = (String) request.getAttribute(Keys.HttpRequest.REQUEST_METHOD);
        if (StringUtils.isBlank(ret)) {
            ret = request.getMethod();
        }

        return ret;
    }
349896
public <T> T get(String restPath, Class<T> expectedResponse, Map<String, String> queryParams) {
		return call(HttpMethod.GET, restPath, expectedResponse, null, queryParams);
	}
722572
private String getAnnotationValue(Annotation annotation) {
        Class<? extends Annotation> type = annotation.annotationType();
        try {
            Method method = type.getDeclaredMethod(VALUE);
            return String.valueOf(method.invoke(annotation, NO_ARGS));
        } catch (NoSuchMethodException e) {
            return null;
        } catch (InvocationTargetException e) {
            return null;
        } catch (IllegalAccessException e) {
            return null;
        }
    }
509652
public static JSONObject getJSONObject(HttpGet request, Integer method, HashMap<String, String> params) throws JSONException {
        switch (method) {
        case METHOD_GET:
            return doGetRequest(request);
        default:
            throw new RuntimeException("Wrong http method requested");
        }
    }
211247
public RouteBuilder get(){

        if(!methods.contains(HttpMethod.GET)){
            methods.add(HttpMethod.GET);
        }
        return this;
    }
846654
@SuppressWarnings("rawtypes")
    protected Object getValue(GetterMethodCover method, Object value) {
        if(method.isByte()) {
            value = ((Byte)value).intValue();
        }
        else if(method.isChar()) {
            value = (int)((Character)value).charValue();
        }
        else if(method.isFloat()) {
            value = ((Float)value).doubleValue();
        }
        else if(method.isLong()) {
            value = ((Long)value).doubleValue();
        }
        else if(method.isShort()) {
            value = ((Short)value).intValue();
        }
        else if(method.isObject()) {
            value = parseObject(method, value);
        }
        else if(method.isObjectArray()) {
            value = parseArray(method, value);
        }
        else if(method.isArrayObjectCollection()) {
            return parseArrayObjectCollection(method, (Collection)value);
        }
        else if(method.isObjectCollection()) {
            return parseObjectCollection(method, (Collection)value);
        }
        else if(method.isArrayCollection()) {
            return parseArrayCollection(method, (Collection)value);
        }
        else if(method.isArray() || method.isColection()) {
            return transformSimpleValue(value);
        }
	    return value;
	}
330134
public Object getArgumentValue() {
        try {
            return getUnderlyingField().get(getContainingObject());
        } catch (final IllegalAccessException e) {
            throw new CommandLineException.ShouldNeverReachHereException(
                    "This shouldn't happen since we setAccessible(true).", e);
        }
    }
678944
public MethodMetaArgs createGetMethod(HandlerMetaDef handlerMetaDef, Object keyValue) {

		String p_methodName = handlerMetaDef.getFindMethod();
		if (p_methodName == null) {
			Debug.logError("[JdonFramework] not configure the findMethod parameter: <getMethod name=XXXXX /> ", module);
		}
		if (keyValue == null) {
			Debug.logError("[JdonFramework] not found model's key value:" + handlerMetaDef.getModelMapping().getKeyName()
					+ "=? in request parameters", module);
		}
		return createCRUDMethodMetaArgs(p_methodName, keyValue);
	}
79432
@Override
	public Collection<HttpMethod> getRequestMethod(Class<?> type, Method method) {
		return METHODS.computeIfAbsent(key(type, method), __ -> delegate.getRequestMethod(type, method));
	}
822099
@Override
    public Object getRequestContents() {
        if (this.bodyParameters.size() == 0) {
            return "{}";
        } else {
            String jsonString = "";
            EntityActionBodyParameterMapper mapper = new EntityActionBodyParameterMapper();
            jsonString = mapper.toString(this.bodyParameters);
            return jsonString;
        }
    }
24537
@Override
	public HashMap<String, Object> getRequestMap() {
		return (HashMap<String, Object>) JKThreadLocal.getValue(JKContextConstants.HTTP_REQUEST_MAP);
	}
1280750
public static String getRequestParameterValue(final HttpServletRequest request, final String key) {
		String[] values = getRequestParameterValues(request, key);
		return values == null || values.length == 0 ? null : values[0];
	}