These parameters are sent with the request to the endpoint specified in the
action option.

@param aParams
New parameters to be added.
@return this
13390
@Nonnull
  public FineUploaderBasic addParams (@Nullable final Map <String, String> aParams)
  {
    m_aRequestParams.addAll (aParams);
    return this;
  }
780796
public MethodConfig setParameters(Map<String, String> parameters) {
        if (this.parameters == null) {
            this.parameters = new ConcurrentHashMap<String, String>();
            this.parameters.putAll(parameters);
        }
        return this;
    }
421551
public static URI addParams(
            final URI uri, final Multimap<String, String> params, final Set<String> overrideParams) {
        if (params == null || params.isEmpty()) {
            return uri;
        }
        final String origTxt = uri.toString();
        int queryStart = origTxt.indexOf('?');
        final StringBuilder result = new StringBuilder();
        if (queryStart < 0) {
            int fragmentStart = origTxt.indexOf('#');
            if (fragmentStart < 0) {
                result.append(origTxt);
            } else {
                result.append(origTxt, 0, fragmentStart);
            }
        } else {
            result.append(origTxt, 0, queryStart);
        }

        Map<String, Collection<String>> origParams = getParameters(uri).asMap();
        boolean first = true;
        for (Map.Entry<String, Collection<String>> param: params.asMap().entrySet()) {
            final String key = param.getKey();
            Collection<String> origList = origParams.remove(key);
            if (origList != null && (overrideParams == null || !overrideParams.contains(key))) {
                first = addParams(result, first, key, origList);
            }
            Collection<String> list = param.getValue();
            first = addParams(result, first, key, list);
        }

        for (Map.Entry<String, Collection<String>> param: origParams.entrySet()) {
            final String key = param.getKey();
            Collection<String> list = param.getValue();
            first = addParams(result, first, key, list);
        }

        if (uri.getFragment() != null) {
            result.append('#').append(uri.getRawFragment());
        }

        try {
            return new URI(result.toString());
        } catch (URISyntaxException e) {
            throw ExceptionUtils.getRuntimeException(e);
        }
    }
854166
@Nonnull
  public MimeType addParameter (@Nonnull final MimeTypeParameter aParameter)
  {
    ValueEnforcer.notNull (aParameter, "Parameter");

    m_aParameters.add (aParameter);
    return this;
  }
353183
def add_params(endpoint, params):
    
    p = PreparedRequest()
    p.prepare(url=endpoint, params=params)
    if PY2:  # pragma: no cover
        return unicode(p.url)
    else:  # pragma: no cover
        return p.url
356874
public Request setParam(String name, Iterable<String> values) {
        this.params.putAll(name, values);
        return this;
    }
658752
public static String addParams(
            final String url, final Multimap<String, String> params, final Set<String> overrideParams)
            throws URISyntaxException {
        return addParams(new URI(url), params, overrideParams).toString();
    }
1102331
public S setParameters(Map<String, String> parameters) {
        if (this.parameters == null) {
            this.parameters = new ConcurrentHashMap<String, String>();
        }
        this.parameters.putAll(parameters);
        return castThis();
    }
953567
@Nonnull
    public ParametersAction merge(@CheckForNull ParametersAction overrides) {
        if (overrides == null) {
            return new ParametersAction(parameters, this.safeParameters);
        }
        ParametersAction parametersAction = createUpdated(overrides.parameters);
        Set<String> safe = new TreeSet<>();
        if (parametersAction.safeParameters != null && this.safeParameters != null) {
            safe.addAll(this.safeParameters);
        }
        if (overrides.safeParameters != null) {
            safe.addAll(overrides.safeParameters);
        }
        parametersAction.safeParameters = safe;
        return parametersAction;
    }
452341
private void addQueryParameters(HttpRequestBase request, Map<String, String> params) {
        if (params != null) {
            URIBuilder builder = new URIBuilder(request.getURI());
            for(Map.Entry<String, String> param : params.entrySet()) {
                builder.addParameter(param.getKey(), param.getValue());
            }
            try {
                request.setURI(builder.build());
            } catch (URISyntaxException e) {
                throw new RuntimeException("Unable to construct API URI", e);
            }
        }
    }
1170173
public function actionSimpleList($aParams = array())
    {
        $aResult = array();
        $items = $this->mapper()->find(array(
            'Criteria' => array(
                'Name' => array(
                    'Type' => Criteria::LIKE,
                    'Value' => '%'.$_GET['term'].'%'
                )
            )
        ));

        if ($items->count()) {
            foreach ($items as $itm) {
                $aResult[] = array(
                    'id' => $itm->getId(),
                    'title' => $itm->getName(),
                    'image' => $itm->getGallery()->getCoverThumbUrl(50, true, 50)
                );
            }
        }

        header("Content-type: application/json");
        echo json_encode($aResult);
        Core::app()->hardEnd();
    }
1057473
public void setSdParams(List<SDParam> sdParams) {
        if (null == sdParams) {
            throw new IllegalArgumentException("sdParams list cannot be null");
        }
        this.sdParams.addAll(sdParams);
    }
897646
@Nonnull
  public MockHttpServletRequest setParameter (@Nonnull final String sName, @Nullable final String [] aValues)
  {
    m_aParameters.remove (sName);
    m_aParameters.addAll (sName, aValues);
    return this;
  }
3653
public B addArrayParameter(final String paramName, final String... array) {
        for (String value : array) {
            httpParams.addParameter(paramName, value);
        }
        return self();
    }
878728
@Override
    public SignUpRequest addAuthenticationParameters(Map<String, Object> parameters) {
        authenticationRequest.addAuthenticationParameters(parameters);
        return this;
    }
186896
public void addParameters(Map<String, Object> parameters, boolean suppressNull) {
        
        for (String name : parameters.keySet()) {
            Object value = parameters.get(name);
            
            if (!suppressNull || value != null) {
                addParameter(name, value);
            }
        }
    }
14691
public Query addCustomUrlParamsByString(String values) {
    if (values == null) {
      return this;
    }
    String[] params = values.split("&");
    for (String value : params) {
      if (StringUtils.isNotBlank(value)) {
        String[] keyValue = value.split("=");
        if (keyValue.length == 2 && StringUtils.isNotBlank(keyValue[0]) && StringUtils.isNotBlank(keyValue[1])) {
          customUrlParams.add(new CustomUrlParam().setKey(keyValue[0]).setValue(keyValue[1]));
        }
      }
    }
    return this;
  }