Add a set of parameters to this request

@param array             $aParameters             The parameters

@return void
518362
public function addParameters(array $aParameters)
    {
        foreach($aParameters as $xParameter)
        {
            if($xParameter instanceof JsCall)
            {
                $this->addParameter(Jaxon::JS_VALUE, 'function(){' . $xParameter->getScript() . ';}');
            }
            else
            {
                $this->pushParameter(Parameter::make($xParameter));
            }
        }
    }
10507
protected function _setInputParams(array &$params) {
        foreach ($params as $paramKey => $paramValue) {
            if (in_array($paramKey, $this->args, true)
                && !is_null($paramValue)
            ) {
                $this->_inputParams[$paramKey] = $paramValue;
            }
        }

        $this->_params = array_merge($this->_params, $this->_inputParams);
    }
876646
private function resolveParameters()
    {
        // Parameters need special handling when adding
        foreach ($this->config['parameters'] as $name => $param) {
            if (!is_array($param)) {
                throw new \InvalidArgumentException(
                    "Parameters must be arrays, {$this->config['name']}.$name is ".gettype($param)
                );
            }
            $param['name'] = $name;
            $this->parameters[$name] = new Parameter(
                $param,
                ['description' => $this->description]
            );
        }

        if ($this->config['additionalParameters']) {
            if (is_array($this->config['additionalParameters'])) {
                $this->additionalParameters = new Parameter(
                    $this->config['additionalParameters'],
                    ['description' => $this->description]
                );
            } else {
                $this->additionalParameters = $this->config['additionalParameters'];
            }
        }
    }
707280
public function setParameters($parameters)
    {
        $this->parameters = [];
        
        foreach ($parameters as $parameter) {
            $this->append($parameter);
        }
        
        return $this;
    }
1221924
public function addParameters(array $parameters, $overwrite = true)
    {
        $this->parameters = ArrayUtils::merge($this->parameters, $parameters, $overwrite);
        $this->links      = [];
    }
168974
private function setParameters($parameters)
    {
        $this->domain = $this->validateConfiguration($parameters['domain']);
        $this->endpoint = $this->validateConfiguration($parameters['endpoint']);
        $this->access_token = $this->validateConfiguration($parameters['token']);
    }
222782
protected function _addUrlParameters($sUrl, $aParams)
    {
        $sDelimiter = ((getStr()->strpos($sUrl, '?') !== false)) ? '&' : '?';
        foreach ($aParams as $sName => $sVal) {
            $sUrl = $sUrl . $sDelimiter . $sName . '=' . $sVal;
            $sDelimiter = '&';
        }

        return $sUrl;
    }
211880
public function setParameters(array $parameters, $append = false)
    {
        if (!$append) {
            $this->parameters = $parameters;
        } else {
            foreach ($parameters as $field => $value) {
                $this->setParameter($field, $value);
            }
        }
    }
708907
public function setParams($params)
    {
        foreach ($params as $name => $value) {
            $this->setParam($name, $value);
        }
        return $this;
    }
1259929
private void addParams(Map<String, Object> dbServiceParams) {
        if (dbServiceParams != null) {
            for (String paramName : dbServiceParams.keySet()) {
                m_serviceParamMap.put(paramName, dbServiceParams.get(paramName));
            }
        }
    }
450317
public function setParams($params)
    {
        // $param should be a single key => value pair
        if (is_array($params)) {
            foreach ($params as $key => $param) {
                $this->params[$key] = $param;
            }
        }
    }
407878
public function addParams($params)
    {
        if (is_null($params)) {
            return;
        }

        if(!is_array($params)) {
            $params = array($params);
        }

        $this->params = array_merge($this->params, $params);
    }
689720
protected function addParameter(array $parameters)
    {
        foreach ($parameters as $paramName => $paramValue) {
            $this->parameters[$paramName] = $paramValue;
            $this->parametersTypes[$paramName] = $this->inferType($paramValue);
        }
    }
222597
public function setParameters(array $parameters)
    {
        $this->storage = new \ArrayObject();
        foreach ($parameters as $parameterName => $parameterValue) {
            $this->setParameter($parameterName, $parameterValue);
        }

        return $this;
    }
622627
public function add(...$parameters)
    {
        if (count($parameters) === 1) {
            $this->routes['regular'][] = ['closure' => $parameters[0], 'groupArgs' => []];
        } elseif (count($parameters) === 2) {
            $this->routes['regular'][] = ['closure' => $parameters[1], 'groupArgs' => $parameters[0]];
        } else {
            throw new \InvalidArgumentException;
        }
    }
15710
public static void addToParameters(final IRequestParameters parameters,
		final Map<String, List<StringValue>> parameterMap)
	{
		for (final String parameterName : parameters.getParameterNames())
		{
			final List<StringValue> parameterValues = parameters.getParameterValues(parameterName);
			parameterMap.put(parameterName, parameterValues);
		}
	}
13390
@Nonnull
  public FineUploaderBasic addParams (@Nullable final Map <String, String> aParams)
  {
    m_aRequestParams.addAll (aParams);
    return this;
  }