Retrieves all parameters that have no namespace

@return array
964383
private function getParametersWithoutNamespace()
    {
        $parameters = array();
        foreach ($this->parameters as $key => $value) {
            if (strpos($key, ':') === false) {
                $parameters[$key] = $value;
            }
        }
        return $parameters;
    }
161083
private function extractArguments(): array
    {
        $parameters = [];

        //Use the Reflection API to create Parameter Value object
        foreach ($this->getReflectionInstance()->getParameters() as $param) {
            $name = $param->getName();
            $hasDefault = $param->isDefaultValueAvailable();

            //Default value. To null if the parameter has no default value
            $defaultValue = null;
            if (true === $hasDefault) {
                $defaultValue = $param->getDefaultValue();
            }
            $class = $param->getClass();

            $parameters[$name] = new Parameter($name, $hasDefault, $defaultValue, $class);
        }

        return $parameters;
    }
162331
public function getParameterValues()
    {
        $values = array();

        foreach ($this->parameters as $name => $parameter) {
            if (!$parameter->isRequired()) {
                $values[$name] = $parameter->getDefaultValue();
            }
        }

        return $values;
    }
325603
private function getCustomParamsArray()
    {
        $customParams = $this->customParams;
        ksort($customParams);
        foreach ($customParams as $key => $value) {
            $customParams[$this->customParamsPrefix . $key] = $value;
            unset($customParams[$key]);
        }
        return $customParams;
    }
46882
public function getParameters()
    {
        $lastIndent = null;
        $parameters = array();

        if ($parameterComment = $this->getParametersComment()) {
            $parameterLines = explode("\n", $parameterComment);
            foreach ($parameterLines as $line) {
                if (empty($line)) {
                    continue;
                }

                $lineParts = explode(' - ', $line);

                $name = trim(array_shift($lineParts));

                $description = '';
                if (!empty($lineParts)) {
                    $description = trim(implode(' - ', $lineParts));
                }
                $parameter = new Parameter($name, $description);

                $parameters[] = $parameter;
            }
        }

        return $parameters;
    }
1114228
public function getNamespaces()
    {
        $db = Database::getActiveConnection();

        /** @var PDOStatement $results */
        $results = $db->createQueryBuilder()
            ->select('configNamespace')
            ->from('Config', 'c')
            ->where('configNamespace != ""')
            ->groupBy('configNamespace')
            ->execute();

        return array_map('array_shift', $results->fetchAll());
    }
114387
final public function getNamespace(): string
    {
        if (null === $this->namespace) {
            $pos             = strrpos(static::class, '\\');
            $this->namespace = false === $pos ? '' : substr(static::class, 0, $pos);
        }

        return $this->namespace;
    }
1007175
private function findFileNamespaces()
    {
        $namespaces = array();

        // namespaces can be only top-level nodes, so we can scan them directly
        foreach ($this->topLevelNodes as $topLevelNode) {
            if ($topLevelNode instanceof Namespace_) {
                $namespaceName = $topLevelNode->name ? $topLevelNode->name->toString() : '';

                $namespaces[$namespaceName] = new ReflectionFileNamespace(
                    $this->fileName,
                    $namespaceName,
                    $topLevelNode
                );
            }
        }

        return $namespaces;
    }
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];
    }
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;
		
	}
1371699
public function listNamespaceNames()
    {
        $sql = $this->_platform->getListNamespacesSQL();

        $namespaces = $this->_conn->fetchAll($sql);

        return $this->getPortableNamespacesList($namespaces);
    }
1250901
protected function getConvertedParameters():array
    {
        $parameters = $this->all();
        $parameters = $this->castBooleans($parameters);
        $parameters = $this->convertToSnakeCase($parameters);

        if (method_exists($this, 'convertParameters')) {
            $parameters = $this->convertParameters($parameters);
        }

        return $parameters;
    }
661805
public function getAllParams()
    {
        $params = [];

        foreach ($this->getDefaultParams() as $key => $value) {
            $params[$key] = $value;
            if (isset($this->_parameters[$key]['value'])) {
                $params[$key]['value'] = $this->_parameters[$key]['value'];
            }
        }

        return $params;
    }
1076844
private function parseParameters(): array
    {
        $arguments = [];
        $options = [];
        $signatureArguments = $this->getParameters();

        foreach ($signatureArguments as $value) {
            $item = [];
            $matches = [];
            $exploded = explode(':', $value);

            if (count($exploded) > 0 && preg_match($this->argumentsMatcher, $exploded[0], $matches)) {
                $item['name'] = $matches[1];
                $item['type'] = $this->defineType($matches[2] === '[]', $matches[3] === '=');
                $item['default'] = $matches[4] !== '' ? $matches[4] : null;
                $item['description'] = count($exploded) === 2 ? $exploded[1] : null;

                if ($matches[2] === '[]' && $item['default'] !== null) {
                    $item['default'] = explode(',', $item['default']);
                }

                if (substr($exploded[0], 0, 2) === '--') {
                    $options[] = $item;
                } else {
                    $arguments[] = $item;
                }
            }
        }

        return [
            'arguments' => $arguments,
            'options' => $options,
        ];
    }
312700
public function getNamespaceAliases()
    {
        if (!isset($this->fileNamespaceAliases)) {
            $this->fileNamespaceAliases = $this->findNamespaceAliases();
        }

        return $this->fileNamespaceAliases;
    }
41137
public function getParams()
    {
        if ($this->cachedParams) {
            return $this->cachedParams;
        }

        $CMDS = [];
        $KEYS = [];
        $ARGV = [];
        $KEYNUM = 0;
        $ARGNUM = 0;

        foreach ($this->stack as $part) {
            list($cmd, $keys, $argv) = $part;

            if (!empty($keys)) {
                $cmd = preg_replace_callback('~KEYS\[(\d+)\]~', function ($m) use (&$KEYS, &$KEYNUM, $keys) {
                    $key = $keys[$m[1] - 1];
                    if (!isset($KEYS[$key])) {
                        $KEYS[$key] = ++$KEYNUM;
                    }
                    return 'KEYS[' . $KEYS[$key] . ']';
                }, $cmd);
            }

            if (!empty($argv)) {
                $cmd = preg_replace_callback('~ARGV\[(\d+)\]~', function ($m) use (&$ARGV, &$ARGNUM, $argv) {
                    $arg = $argv[$m[1] - 1];
                    if (!isset($ARGV[$arg])) {
                        $ARGV[$arg] = ++$ARGNUM;
                    }
                    return 'ARGV[' . $ARGV[$arg] . ']';
                }, $cmd);
            }

            $CMDS[] = $cmd;
        }

        return $this->cachedParams = array_merge(
            [implode(';', $CMDS), count($KEYS)],
            array_keys($KEYS),
            array_keys($ARGV)
        );
    }
214186
public function getNamespace()
    {
        $segments = $this->getSegments();
        array_pop($segments);
        $rootNamespace = $this->getRootNamespace();
        if ($rootNamespace == false) {
            return null;
        }

        return 'namespace ' . rtrim($rootNamespace . '\\' . implode($segments, '\\'), '\\') . ';';
    }