returns as Parameters instance

@return Parameters
17574
public function asParameters() : Parameters
    {
        if ($this->parameters === null) {
            $this->parameters = new Parameters($this->all());
        }
        return $this->parameters;
    }
1193579
public function makeParameter()
    {
        $ret = [];
        foreach ($this->parameters as $k => $v) {
            if ($v !== null) {
                $ret[$k] = $v;
            }
        }
        return $ret;
    }
179847
public final Collection<String> getParameters() {
        ArrayList<String> params = new ArrayList<String>();
        
        if( parameters == null ) {
            return params;
        }
        // we copy to guarantee that the caller does not screw up our internal storage
        params.addAll(Arrays.asList(parameters));
        return params;
    }
602721
function getParams()
    {
        $params = array();
        foreach (get_object_vars($this) as $k => $v) {
            if ($k[0] == '_') {
                $params[substr($k, 1)] = $v;
            }
        }

        return $params;
    }
1044846
public function getParameters()
    {
        $params = array();
        foreach ($this->parameters as $name => $param) {
            $params[$name] = htmlentities($param, ENT_QUOTES, 'UTF-8', false);
        }
        return $params;
    }
101893
public function getParameterString()
    {
        $str = "$" . $this->getParameterName();
        if ($this->parameterType) {
            $str .= " [" . $this->getParameterType() . "]";
        }
        return $str;
    }
669500
public function InParameter()
    {
        if ($this->lexer->lookahead['type'] == Lexer::T_INPUT_PARAMETER) {
            return $this->InputParameter();
        }

        return $this->Literal();
    }
1147549
public function getFilterParameters()
    {
        $parameters = parent::getFilterParameters();

        // build the values array
        if ($this->hasRequest()) {
            /** @var Request $request */
            $request = $this->getRequest();

            $parentAssociationMapping = $this->getParentAssociationMapping();

            // always force the parent value
            if ($parentAssociationMapping && $this->isChild()) {
                /** @var \Sonata\AdminBundle\Admin\AbstractAdmin $parent */
                $parent = $this->getParent();

                $name = str_replace('.', '__', $parentAssociationMapping);

                $idParameter = $parent->getIdParameter();

                $parameters[$name] = ['value' => $request->get($idParameter)];

                if (ClassMetadataInfo::MANY_TO_MANY === $this->getParentAssociationMappingType()) {
                    $parameters[$name] = ['value' => [$request->get($idParameter)]];
                }
            }
        }

        return $parameters;
    }
209069
public function getParameters()
    {
        // If the parameters property is null, it still hasn't been set. Parse
        // the path components first.
        if (is_null($this->parameters)) {
            $this->parameters = $this->parsePath();
        }

        return $this->parameters;
    }
410285
public function getParameters()
    {
        if (null === $this->getParameter('PBX_HMAC')) {
            $this->setParameter('PBX_TIME', date('c'));
            $this->setParameter('PBX_HMAC', strtoupper($this->computeHmac()));
        }

        $resolver = new ParameterResolver($this->globals['currencies']);

        return $resolver->resolve($this->parameters);
    }
1193522
@Override
    public String parameters() {
        return Op.join(" ", start, direction)
                + (!Op.isEq(height, 1.0) ? " " + Op.str(height) : "");
    }
847555
public function getParams()
    {
        if (empty($this->params)) {
            return '';
        }

        $params = array_map(function ($key, $value) {
            return "$key=$value";
        }, array_keys($this->params), $this->params);

        return '?'.implode('&', $params);
    }
11516
public function parameters(): array
    {
        return array_map(
                function($parameter)
                {
                    $param = new Parameter(
                            $parameter->getName(),
                            $parameter->getDescription(),
                            $parameter->getIn()
                    );

                    if ($parameter->hasValueByName('required') && $parameter->isRequired()) {
                        $param->markRequired();
                    }

                    return $param;
                },
                $this->annotations->named('Parameter')
        );
    }
960431
public function getParams()
    {
        $res = [];
        if ($this->_params instanceof Closure) {
            $res = call_user_func($this->_params, $this);
        } else {
            foreach ($this->_params as $k => $v) {
                $res[$k] = $v instanceof Closure ? call_user_func($v, $this, $this->getModel()) : $v;
            }
        }

        return array_merge($res, $this->prepareData($res));
    }
1080391
private function getParameters() {
		
		$url = '/' == $this->url{0} ? substr($this->url,1) : $this->url;
		
		// split parameters by slash
		$params = explode('/', $url);
		
		// reveal ajax calls and raw requests and cuts special prefix from URL
		if (array_key_exists(0, $params)) {
			
			switch ($params[0]) {
				
				case 'ajax':
					$this->ajax = $this->raw = TRUE;
					array_shift($params);
					break;
					
				case 'raw':
					$this->raw = TRUE;
					array_shift($params);
					break;
					
			}
			
		}
		
		return $params;
		
	}
509000
public function getForDynamoDB()
    {
        $action = $this->getAction();
        $value = $this->getValue();

        $parameters['Action'] = $action;
        if (isset($value)) {
            $parameters['Value'] = $value->getForDynamoDB();
        }

        return $parameters;
    }
440759
private function parameter() {
    $node = new ParameterNode();
    if ($type = $this->optionalTypeHint()) {
      $node->addChild($type, 'typeHint');
    }
    $this->tryMatch('&', $node, 'reference');
    $this->tryMatch(T_ELLIPSIS, $node, 'variadic');
    $this->mustMatch(T_VARIABLE, $node, 'name', TRUE);
    if ($this->tryMatch('=', $node)) {
      $node->addChild($this->staticScalar(), 'value');
    }
    return $node;
  }