Get the parameters for the given class / method by string.

@param  string  $uses
@return array
434217
protected static function fromClassMethodString($uses)
    {
        [$class, $method] = Str::parseCallback($uses);

        if (! method_exists($class, $method) && is_callable($class, $method)) {
            return [];
        }

        return (new ReflectionMethod($class, $method))->getParameters();
    }
1161770
private function getParameters($namespace)
    {
        $parameters = [];

        /** @var Parameter $parameter */
        foreach ($this->parameterRepository->findBy(['namespace' => $namespace]) as $parameter) {
            $parameters[$parameter->getName()] = $parameter->getValue();
        }

        return $parameters;
    }
314575
public static function groupUsesForChart($uses)
    {
        $labels = [];
        $data = [];

        ArrayHelper::multisort($uses, 'date');

        foreach ($uses as $use) {
            /** @var ServerUse $use */
            $labels[$use->date] = $use;
            $data[$use->type][] = $use->getDisplayAmount();
        }

        foreach ($labels as $date => $use) {
            $labels[$date] = $use->getDisplayDate();
        }

        return [$labels, $data];
    }
1018513
public function getParametersForAlias($alias)
    {
        foreach ($this->classMap as $item => $parameters) {
            if ($parameters['alias'] == $alias) {
                $parameters['class'] = $item;

                return $parameters;
            }
        }

        return null;
    }
425064
public function getMethod($class, $method, $extraMappings = []) {
		if (isset($this->aliases[$class])) {
			$class = $this->aliases[$class];
		}

		return [
			$this->getSingleton($class),
			$this->resolveArgs($class, $method, " when resolving method $class::$method", $extraMappings)
		];
	}
167555
protected function getMethods($options)
	{
		if (isset($options['only']) && count($options['only']) > 0)
		{
			return $options['only'];
		}
		elseif (isset($options['except']) && count($options['except']) > 0)
		{
			return array_diff($this->defaults, $options['except']);
		}

		return $this->defaults;
	}
143175
protected function getSupportedParams($method)
    {
        $columns = [];

        if ($this->isEloquentBuilder()) {
            $model = $this->getHandler()->getModel();
            $columns = in_array(ApiHelper::class, class_uses($model))
                ? $model->$method()
                : $model->getFillable();
        }

        return $columns;
    }
445162
private function getParameterValues ($function, array $parameters = []) {
        $functionParams = [];
        $parameterIndex = 0;
        foreach ($function->getParameters() as $parameter) {
            $parameterName = $parameter->getName();
            $parameterValue = null;

            if (array_key_exists($parameterName, $parameters)) {
                $parameterValue = $parameters[$parameterName];
            }
            else if ($parameter->hasType()) {
                $type = $parameter->getType();
                if (!$type->isBuiltin()) {
                    $typeName = (string)$type;
                    if (array_key_exists($typeName, $parameters)) {
                        $parameterValue = $parameters[$typeName];
                    }
                    else if (!$parameter->isDefaultValueAvailable()) {
                        $typeClass = new ReflectionClass($typeName);
                        foreach ($typeClass->getMethods(ReflectionMethod::IS_STATIC) as $staticMethod) {
                            if ($staticMethod->getReturnType() != null && ((string)$staticMethod->getReturnType() == $typeName) && $staticMethod->getNumberOfParameters() == 0) {
                                $parameterValue = $staticMethod->invoke(null);
                                break;
                            }
                        }
                    }
                }
            }

            if ($parameterValue == null) {
                if (array_key_exists($parameterIndex, $parameters)) {
                    $parameterValue = $parameters[$parameterIndex];
                    $parameterIndex++;
                }
                else if ($parameter->isDefaultValueAvailable()) {
                    $parameterValue = $parameter->getDefaultValue();
                }
            }
            $functionParams[] = $parameterValue;
        }
        return $functionParams;
    }
241973
protected function parameterValues($parameters)
    {
        $values = array();
        foreach ($parameters as $value) {
            $values[] = is_array($value) ? $value['value'] : $value;
        }
        return $values;
    }
388685
protected function _getMethods($object)
    {
        if (is_string($object)) {
            $className = $object;
        } else {
            $className = get_class($object);
        }
        $methods = get_class_methods($className);

        if (self::$_config['sort']['methods']) {
            sort($methods);
        }
        return $methods;
    }
954231
public function getParameters($asString = false)
    {
        if ($asString) {
            $str = (string) $this->getParameterContainer();
            return $str;
        }
        return $this->getParameterContainer()->all();
    }
808706
public function getParams(): array
    {
        $params = array();
        $args = $this->args;

        $params['apikey'] = $this->apiKey;

        $methods = Client::getMethods();

        foreach ($methods[$this->method] as $key => $paramName) {
            if (isset($args[$key])) {
                $params[$paramName] = $args[$key];
            }
        }

        return $params;
    }
653919
public function getUseStatements(): array
    {
        // Check cache.
        if (null === $this->use_statements) {
            $this->use_statements = [];

            // Fetch start of class so we do not
            // include use statements that import traits.
            $tokens = $this->getTokenStream();
            $class  = $this->getClassNameLocation();

            // Find all the use statements and parse them one by one
            // and then add them to the use_statements cache.
            $loc = 0;
            while (($loc = $tokens->scan($loc, [T_USE])) && $loc < $class) {
                [$alias, $use_statement] = $this->parseUse($loc++);
                if ($alias !== null) {
                    $this->use_statements[$alias] = $use_statement;
                } else {
                    $this->use_statements[] = $use_statement;
                }
            }
        }

        return $this->use_statements;
    }
861812
public function parameters()
	{
		$build = array();

		foreach (get_class_methods($this) as $method)
		{
			if (substr($method, -strlen('Parameter')) !== 'Parameter')
			{
				continue;
			}

			if ($called = call_user_func(array($this, $method)))
			{
				$build = array_replace($build, $called);
			}
		}

		return '?' . http_build_query($build);
	}
291976
protected function getFindMethodAndParameters()
    {
        $method = '';
        $parameters = [];

        switch ($this->type) {
            case 'string':
                $method = 'get';
                break;
            case 'list':
                $method = 'lrange';
                $parameters = [0, -1];
                break;
            case 'set':
                $method = 'smembers';
                break;
            case 'zset':
                $method = 'zrange';
                $parameters = [0, -1];
                break;
            case 'hash':
                $method = 'hgetall';
                break;
            default:
                break;
        }

        return [$method, $parameters];
    }
311882
protected function getParameters()
    {
        $strings = array();

        foreach ($this->getParameterInfo() as $name => $parameter) {
            if ($parameter['type']) {
                $strings[] = ':type $' . $name . ': ' . $parameter['type'];
            }

            $string = ':param $' . $name . ':';

            if (isset($parameter['comment']) && $parameter['comment']) {
                $string .= ' ' . $parameter['comment'];
            }

             $strings[] = $string;
        }

        return $strings;
    }
1023282
public static function getClassMethodArgs($class, string $method)
    {
        static $cache = null;

        if (null !== $cache && isset($cache[$class][$method])) {
            return $cache[$class][$method];
        }

        $reflector = new \ReflectionMethod($class, $method);
        $params = $reflector->getParameters();
        if (empty($params)) {
            $cache[$class][$method] = [];
            return [];
        }
        $args = [];
        foreach ($params as $param) {
            $args[$param->name] = [
                'optional' => $param->isOptional(),
                'variadic' => $param->isVariadic(),
            ];
            if ($param->isOptional() && $param->isDefaultValueAvailable()) {
                $args[$param->name]['default'] = $param->getDefaultValue();
            }
            if ($param->hasType()) {
                $args[$param->name]['type'] = (string)$param->getType();
            }
        }
        $cache[$class][$method] = $args;
        return $args;
    }