<p>extractParameterMultiple.</p>

@param name a {@link java.lang.String} object.
@param parameters a {@link java.util.Map} object.
@return an array of {@link java.lang.String} objects.
13854
public static String[] extractParameterMultiple(String name, Map parameters) {
		String paramValues = extractParameter(name, parameters);
		return StringUtils.stripAll(StringUtils.split(paramValues, ", "));
	}
231829
public Hashtable getParams(String name)
    {
        List part = (List)_partMap.getValues(name);
        if (part==null)
            return null;
        return ((Part)part.get(0))._headers;
    }
791563
@Override
    public String getParameter(String name) {
        String value = super.getParameter(name);
        if (value == null) {
            value = parameters.get(name);
        }
        return value;
    }
502113
public String getParameter(String name) {
        String[] values = parameters.get(name);
        if (values == null) {
            return null;
        }

        if (values.length == 0) {
            return "";
        }
        return values[0];
    }
306929
public String[] getArrayParam(String paramName) {
		if (requestParameters == null) {
			return null;
		}
		return requestParameters.get(paramName);
	}
1298406
public String param(final String name) {
        try {
            return request.getParameter(name);
        } catch (final Exception e) {
            LOGGER.log(Level.ERROR, "Can't parse request parameter [uri=" + request.getRequestURI() + ", method=" + request.getMethod() + ", parameterName=" + name + "]: " + e.getMessage());

            return null;
        }
    }
640889
public List<String> params(String name) {
		List<String> values = queryParams.get(name);
		String value = pathParams.get(name);

		if (values == null) {
			return (value == null) ? Collections.<String>emptyList() : Collections.singletonList(value);
		}

		if (value == null) {
			return Collections.unmodifiableList(values);
		} else {
			List<String> aggregated = new ArrayList<String>(values.size() + 1);
			aggregated.addAll(values);
			aggregated.add(value);
			return Collections.unmodifiableList(aggregated);
		}
	}
683920
Parameter getCreateParameter(String name) {
		if (this.parameters == null)
			this.parameters = new HashMap<String, Parameter>();
		Parameter param = this.parameters.get(name);
		if (param == null) {
			param = new Parameter(name);
			this.parameters.put(name, param);
		}
		return param;
	}
1181495
protected String getParameterOrException(Map<String, String> parameters, String paramName)
        throws TransformationOperationException {
        return getParameter(parameters, paramName, true, null);
    }
13199
public String[] nameToUrls(final String name) throws IOException {

		NameValuePair[] args = {
				new NameValuePair(
						ResourceFileLocationDBServlet.OPERATION_ARGUMENT,
						ResourceFileLocationDBServlet.LOOKUP_OPERATION),
					
				new NameValuePair(
						ResourceFileLocationDBServlet.NAME_ARGUMENT,
						name)
		};
		String locations = doGetMethod(args);
		if(locations != null) {
			return locations.split("\n");
		}
		return null;
	}
1020613
private static ParameterFiller parseParameter(String parameter) {
    String wrappedParameter = "{" + parameter + "}";
    String trimmedParameter = parameter.trim();
    ParameterFiller parameterFiller = parseDateParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseLevelParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseTagParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseMessageParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    return null;
  }
1055133
function (parameters, name) {
                var
                    len,
                    idx,
                    parameter;
                len = parameters.length;
                for (idx = 0; idx < len; ++idx) {
                    parameter = parameters[idx];
                    if (parameter._name === name) {
                        return parameter;
                    }
                }
                return null;
            }
1292371
public static void extractParameterMap(final HttpServletRequest request, final Map<String, String[]> parameters,
			final Map<String, FileItem[]> files) {

		if (isMultipart(request)) {
			ServletFileUpload upload = new ServletFileUpload();
			upload.setFileItemFactory(new DiskFileItemFactory());
			try {
				List fileItems = upload.parseRequest(request);

				uploadFileItems(fileItems, parameters, files);
			} catch (FileUploadException ex) {
				throw new SystemException(ex);
			}
			// Include Query String Parameters (only if parameters were not included in the form fields)
			for (Object entry : request.getParameterMap().entrySet()) {
				Map.Entry<String, String[]> param = (Map.Entry<String, String[]>) entry;
				if (!parameters.containsKey(param.getKey())) {
					parameters.put(param.getKey(), param.getValue());
				}
			}
		} else {
			parameters.putAll(request.getParameterMap());
		}
	}
1266670
public static void addParameters(final IRequestParameters parameters,
		final Map<String, String[]> parameterMap)
	{
		final Set<String> parameterNames = parameters.getParameterNames();
		for (final String parameterName : parameterNames)
		{
			final List<StringValue> parameterValues = parameters.getParameterValues(parameterName);
			String[] stringArray = { };
			if ((parameterValues != null) && !parameterValues.isEmpty())
			{
				stringArray = new String[parameterValues.size()];
				for (int i = 0; i < parameterValues.size(); i++)
				{
					stringArray[i] = parameterValues.get(i).toString();
				}
				if (parameterMap.containsKey(parameterName))
				{
					stringArray = ArrayUtils.addAll(parameterMap.get(parameterName), stringArray);
				}
			}
			parameterMap.put(parameterName, stringArray);
		}
	}
425421
public static List<String> params(String name){
        String[] values = RequestContext.getHttpRequest().getParameterValues(name);
        List<String>valuesList = null;
        if (name.equals("id")) {
            if(values.length == 1){
                valuesList = Collections.singletonList(values[0]);
            }else if(values.length > 1){
                valuesList = asList(values);
            }
        } else {
            valuesList = values == null? new ArrayList<String>() : list(values);
            String userSegment = RequestContext.getRequestVo().getUserSegments().get(name);
            if(userSegment != null){
                valuesList.add(userSegment);
            }
        }
        return valuesList;
    }
511071
public static MBeanParameterInfo[] extractParameterInfo(Method m) {
        Class<?>[] types = m.getParameterTypes();
        Annotation[][] annotations = m.getParameterAnnotations();
        MBeanParameterInfo[] params = new MBeanParameterInfo[types.length];
        for(int i = 0; i < params.length; i++) {
            boolean hasAnnotation = false;
            for(int j = 0; j < annotations[i].length; j++) {
                if(annotations[i][j] instanceof JmxParam) {
                    JmxParam param = (JmxParam) annotations[i][j];
                    params[i] = new MBeanParameterInfo(param.name(),
                                                       types[i].getName(),
                                                       param.description());
                    hasAnnotation = true;
                    break;
                }
            }
            if(!hasAnnotation) {
                params[i] = new MBeanParameterInfo("", types[i].getName(), "");
            }
        }

        return params;
    }
1302792
public MethodNode getMethod(String name, Parameter[] parameters) {
        for (MethodNode method : getMethods(name)) {
            if (parametersEqual(method.getParameters(), parameters)) {
                return method;
            }
        }
        return null;
    }