Gets all the arguments

@return array
428038
public function getArguments(): array
    {
        // We will need to process the arguments and merge them.
        $arguments = array_map([$this, 'processArgument'], $this->arguments);

        return array_merge($arguments, $this->rawArguments);
    }
417644
protected function getArguments()
    {
        return array(
            array('name', InputArgument::REQUIRED, false),
            array('type', InputArgument::OPTIONAL, false),
            array('folder', InputArgument::OPTIONAL, false),
        );
    }
689158
public function getArgumentDefaults()
    {
        $values = [];
        foreach ($this->arguments as $argument) {
            $values[$argument->getName()] = $argument->getDefault();
        }

        return $values;
    }
135431
public function getAll()
    {
        $this->initializeOnDemand();
        $result = array();

        foreach ($this->cache as $key => $options) {
            $result[$key] = $options[ConstProviderInterface::CACHE_PARAM_VALUE];
        }

        return $result;
    }
249335
protected function getArgDefinitions()
    {
        return new ArgumentCollection(
            Argument::createIntListTypeArgument('id'),
            new Argument(
                'filtertype',
                new TypeCollection(
                    new Type\AlphaNumStringListType()
                )
            ),
            new Argument(
                'order',
                new TypeCollection(
                    new Type\EnumListType(array(
                        'alpha',
                        'alpha-reverse',
                        'random',
                        'given_id'
                    ))
                ),
                'alpha'
            )
        );
    }
1342992
public function getParams()
    {
        $params = [];
        foreach ($this as $key => $value) {
            $pname = (string) ltrim(strtolower(preg_replace('/[A-Z]/', '_$0', $key)), '_');
            $params[$pname] = $value;
        }
        return $params;
    }
673951
protected function getArgumentValues(): Collection
    {
        return (new Collection($this->fieldValue->getField()->arguments))
            ->map(function (InputValueDefinitionNode $inputValueDefinition): ArgumentValue {
                return new ArgumentValue($inputValueDefinition, $this->fieldValue);
            });
    }
397282
public function getArguments() {
        if (is_null($this->result)) {
            $this->parse();
        }
        return $this->result[Parser::RESULT_ARGUMENTS];
    }
70991
public function toArray()
    {
        $array = [
            'name'      => $this->getName(),
            'arguments' => $this->getArguments(),
            'children'  => array()
        ];

        foreach ($this->children as $child) {
            $array['children'][] = $child->toArray();
        }
        return $array;
    }
1015098
public function getAll()
    {
        return array(
            self::DEVELOPMENT => self::DEVELOPMENT,
            self::TESTING     => self::TESTING,
            self::STAGING     => self::STAGING,
            self::PRODUCTION  => self::PRODUCTION,
            );
    }
14830
protected function getData()
    {
        if ($this->argument('user')) {
            return [
                'name' => $this->argument('name'),
                'user' => $this->argument('user'),
                'password' => $this->argument('password')
            ];
        } else {
            return [
                'name' => $this->argument('name')
            ];
        }
    }
256814
protected function getArguments()
    {
        $strings = array();

        foreach ($this->getParameterInfo() as $name => $parameter) {
            $string = '';

            if ($parameter['hint_type']) {
                $string .= $parameter['hint_type'] . ' ';
            }

            $string .= '$' . $name;

            if (isset($parameter['default'])) {
                if ($parameter['default'] == '~~NOT RESOLVED~~') {
                    $parameter['default'] = '';
                }
                $string .= ' = ' . $parameter['default'];
            }

            $strings[] = $string;
        }

        return implode(', ', $strings);
    }
143612
public function getArguments(): array
    {
        // We will need to process the arguments and merge them.
        $arguments = parent::getArguments();

        // If we have outfile setup don't act!
        foreach ($arguments as $argument) {
            if (strstr($argument, '-outfile') !== false) {
                return $arguments;
            }
        }

        if ($this->isOutSourceEqual()) // Check if not already specified
        {
            $this->outFileTemp = tempnam(sys_get_temp_dir(), 'img-prfy-');
            $arguments[] = '-outfile '.escapeshellarg($this->outFileTemp);
        } else {
            $arguments[] = '-outfile '.escapeshellarg($this->getOutFile());
        }

        return $arguments;
    }
1060883
protected function getModelArguments() : array
    {
        $models = $this->argument('models');

        if (empty($models)) {
            $models = [
                '\Laranix\Auth\Email\Verification\Verification',
                '\Laranix\Auth\Password\Reset\Reset'
            ];
        }

        return $this->validateArgs($models);
    }
977393
public function getAllParameters()
	{
		// Collect parameters used in template
		$params = [];
		foreach ($this->configurator->tags as $tag)
		{
			if (isset($tag->template))
			{
				foreach ($tag->template->getParameters() as $paramName)
				{
					$params[$paramName] = '';
				}
			}
		}

		// Merge defined parameters and those collected from templates. Defined parameters take
		// precedence
		$params = iterator_to_array($this->parameters) + $params;

		// Sort parameters by name for consistency
		ksort($params);

		return $params;
	}
88782
public function getNamedArguments() : \ArrayObject
    {
        $args = $this->getArguments();
        $paramas = $this->getMethod()->getParameters();
        $namedParams = new \ArrayObject;
        foreach ($paramas as $param) {
            $namedParams[$param->getName()] = $args[$param->getPosition()];
        }

        return $namedParams;
    }
1308475
private function getServerArguments() {
        $args = $_SERVER['argv'];
        array_shift($args);

        $args = $this->parseArgs($args);

        return $args;
    }