Returns an string of all tokens that can be considered being command arguments, using the current token position.
@return argument string
331605
public String getArgs(){
		int count = (this.tokenPosition==0)?1:this.tokenPosition+1;
		String[] ar = StringUtils.split(this.line, null, count);
		if(ar!=null && ar.length>(this.tokenPosition)){
			return StringUtils.trim(ar[this.tokenPosition]);
		}
		return null;
	}
627969
private static String showCommandAliases() {
        final Command[] commands = Command.values();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < commands.length; ++i) {
            if (i != 0) {
                sb.append(", ");
                if (i == commands.length - 1) {
                    sb.append("or ");
                }
            }
            sb.append("`--");
            sb.append(commands[i].getAlias());
            sb.append("`");
        }
        return sb.toString();
    }
916575
public function getUsage()
    {
        $string = [];

        $string[] = $this->getName();

        foreach ($this->getArguments() as $argument) {
            if ($argument->isRequired()) {
                $string[] = $argument->getName();
            } else {
                $string[] = "[{$argument->getName()}]";
            }
        }

        foreach ($this->getOptions() as $option) {
            $dashes = '-';
            if (!$option->isFlagOption()) {
                $dashes .= '-';
            }
            if ($option->isValueRequired()) {
                $optionString = "{$option->getName()}=value";
            } else {
                $optionString = "{$option->getName()}[=value]";
            }
            $string[] = "[{$dashes}{$optionString}]";
        }

        return implode(' ', $string);
    }
969710
protected function getAtoumArguments()
    {
        $inlinedArguments = array();

        foreach ($this->atoumArguments as $name => $values) {
            $inlinedArguments[] = $name;
            if (null !== $values) {
                $inlinedArguments[] = $values;
            }
        }

        return $inlinedArguments;
    }
975695
private function getCommandText() : string
    {
        if (count($this->commandCollection->getAll()) === 0) {
            return '  <info>No commands</info>';
        }

        /**
         * Sorts the commands by name
         * Uncategorized (commands without ":" in their names) always come first
         *
         * @param ICommand $a
         * @param ICommand $b
         * @return int The result of the comparison
         */
        $sort = function ($a, $b) {
            if (strpos($a->getName(), ':') === false) {
                if (strpos($b->getName(), ':') === false) {
                    // They're both uncategorized
                    return $a->getName() < $b->getName() ? -1 : 1;
                } else {
                    // B is categorized
                    return -1;
                }
            } else {
                if (strpos($b->getName(), ':') === false) {
                    // A is categorized
                    return 1;
                } else {
                    // They're both categorized
                    return $a->getName() < $b->getName() ? -1 : 1;
                }
            }
        };

        $commands = $this->commandCollection->getAll();
        usort($commands, $sort);
        $categorizedCommandNames = [];
        $commandTexts = [];
        $firstCommandNamesToCategories = [];

        foreach ($commands as $command) {
            $commandNameParts = explode(':', $command->getName());

            if (count($commandNameParts) > 1 && !in_array($commandNameParts[0], $firstCommandNamesToCategories)) {
                $categorizedCommandNames[] = $command->getName();

                // If this is the first command for this category
                if (!in_array($commandNameParts[0], $firstCommandNamesToCategories)) {
                    $firstCommandNamesToCategories[$command->getName()] = $commandNameParts[0];
                }
            }

            $commandTexts[] = [$command->getName(), $command->getDescription()];
        }

        return $this->paddingFormatter->format($commandTexts,
            function ($row) use ($categorizedCommandNames, $firstCommandNamesToCategories) {
                $output = '';

                // If this is the first command of its category, display the category
                if (in_array(trim($row[0]),
                        $categorizedCommandNames) && isset($firstCommandNamesToCategories[trim($row[0])])
                ) {
                    $output .= "<comment>{$firstCommandNamesToCategories[trim($row[0])]}</comment>" . PHP_EOL;
                }

                return $output . "  <info>{$row[0]}</info> - {$row[1]}";
            });
    }
560960
public function getCommand()
    {
        return sprintf(
            "put %d %d %d %d",
            $this->_priority,
            $this->_delay,
            $this->_ttr,
            strlen($this->_message)
        );
    }
523642
public function getCommandline(): array
    {
        $args = $this->getArguments();
        if ($this->executable !== null && $this->executable !== '') {
            array_unshift($args, $this->executable);
        }

        return $args;
    }
1174117
public function getDrawString()
    {
        $output = $this->prompt;
        if ($this->echo !== false) {
            if ($this->echo === true) {
                $buffer = $this->linebuffer;
            } else {
                $buffer = str_repeat($this->echo, $this->strlen($this->linebuffer));
            }

            // write output, then move back $reverse chars (by sending backspace)
            $output .= $buffer . str_repeat("\x08", $this->strwidth($buffer) - $this->getCursorCell());
        }

        return $output;
    }
1106728
protected function getMappedArguments()
    {
        $requiredArgs = array(
            'client'       => 'Prefix',
            'tool-title'   => 'Tool title',
            'transparent'  => '(1 or 0)',
            'rotatable'    => '(1 or 0)',
            'movable'      => '(1 or 0)',
            'adjustable-x' => '(1 or 0)',
            'adjustable-y' => '(1 or 0)',
        );
        $argHelp = "<p>Required arguments are:</p><ul>";
        foreach ($requiredArgs as $key => $value) {
            $argHelp .= '<li>' . $key . ': ' . $value . '</li>';
        }
        $argHelp .= '</ul>';

        foreach ($requiredArgs as $key => $value) {
            // !string '0' is a valid entry!
            if (!isset($_POST[$key]) || $_POST[$key] === '') {
                throw new \Exception($argHelp);
                break;
            }
            // trim all, cast 0|1 to bool
            $_POST[$key] = trim($_POST[$key]);
            if (in_array($_POST[$key], array('0', '1'))) {
                $_POST[$key] = (bool)$_POST[$key];
            }
        }

        $_POST['client']           = strtoupper($_POST['client']);
        $_POST['tool-base']        = StringUtils::removeSpecChars($_POST['tool-title']);
        $_POST['tool-fn']          = StringUtils::camelize($_POST['tool-base']);
        $_POST['tool-obj']         = ucfirst($_POST['tool-fn']);
        $_POST['tool-id']          = strtolower($_POST['client']) . $_POST['tool-obj'];
        $_POST['is-transparent']   = json_encode($_POST['transparent']);
        $_POST['is-rotatable-tl']  = json_encode($_POST['rotatable']); // default position of rotator

                                        // only visible when not adjustable
        $_POST['is-rotatable-tr']  = json_encode($_POST['rotatable'] && (!$_POST['adjustable-x'] && !$_POST['adjustable-y']));
        $_POST['is-rotatable-br']  = json_encode($_POST['rotatable'] && (!$_POST['adjustable-x'] && !$_POST['adjustable-y']));

        $_POST['is-rotatable-bl']  = json_encode($_POST['rotatable']); // also default position of rotator

        // alternative positions, need to be configured manually
        $_POST['is-rotatable-t']  = json_encode(false);
        $_POST['is-rotatable-r']  = json_encode(false);
        $_POST['is-rotatable-b']  = json_encode(false);
        $_POST['is-rotatable-l']  = json_encode(false);

        $_POST['is-movable']       = json_encode($_POST['movable']);
        $_POST['is-adjustable-x']  = json_encode($_POST['adjustable-x']);
        $_POST['is-adjustable-y']  = json_encode($_POST['adjustable-y']);
        $_POST['is-adjustable-xy'] = json_encode($_POST['adjustable-x'] && $_POST['adjustable-y']);

        unset($_POST['transparent']);
        unset($_POST['rotatable']);
        unset($_POST['movable']);
        unset($_POST['adjustable-x']);
        unset($_POST['adjustable-y']);

        return $_POST;
    }
1266344
protected function getFullCommandName()
    {
        $name = $this->name;

        foreach( $this->getArguments() as $argument ) {
            $argumentName = $argument[ 0 ];
            $argumentValue = $this->input->getArgument($argumentName);

            if( strpos($this->name, '{'. $argumentName .'}') !== false ) {
                $name = str_replace('{'. $argumentName .'}', $argumentValue, $this->name);
            } else {
                $name .= ' '. $argumentValue;
            }
        }

        foreach( $this->getOptions() as $option ) {
            $key = $option[ 0 ];
            $name .= ' --'. $key .'='. $this->input->getOption( $key );
        }

        return $name;
    }
151535
protected function getRoutineArgs(): string
  {
    $ret = '';

    foreach ($this->routine['parameters'] as $parameter_info)
    {
      $mangledName = $this->nameMangler->getParameterName($parameter_info['parameter_name']);

      if ($ret) $ret .= ',';
      $ret .= DataTypeHelper::escapePhpExpression($parameter_info, '$'.$mangledName, $this->lobAsStringFlag);
    }

    return $ret;
  }
1317709
public function getArguments()
    {
        $returnArray = [];
        foreach ($this->commandArguments as $argument) {
            $returnArray[$argument->getName()] = $argument->getValue();
        }
        return $returnArray;
    }
397282
public function getArguments() {
        if (is_null($this->result)) {
            $this->parse();
        }
        return $this->result[Parser::RESULT_ARGUMENTS];
    }
173345
public function getCommand() : string
    {
        return $this->cmd
        . (count($this->options)   ? ' ' . implode(' ', $this->options)   : '')
        . ($this->isSilent         ? ' 2> /dev/null'                      : '');
    }
752818
private function getCLISubjects()
    {
        $command = '';
        if (!is_null($this->commandSubject)) {
            $command .= ' ';
            if ($this->commandSubject instanceof SubCommandCommand) {
                $command .= $this->commandSubject->getCommand();
            } else {
                if (is_array($this->commandSubject)) {
                    $command .= implode(' ', array_map('escapeshellarg', $this->commandSubject));
                } else {
                    $command .= escapeshellarg($this->commandSubject);
                }
            }
        }
        if (!is_null($this->commandSubject2)) {
            $command .= ' ';
            if ($this->commandSubject2 instanceof SubCommandCommand) {
                $command .= $this->commandSubject2->getCommand();
            } else {
                if (is_array($this->commandSubject2)) {
                    $command .= implode(' ', array_map('escapeshellarg', $this->commandSubject2));
                } else {
                    $command .= escapeshellarg($this->commandSubject2);
                }
            }
        }
        return $command;
    }
662530
public function getProcessedHelp()
    {
        $name = $this->name;
        $isSingleCommand = $this->application && $this->application->isSingleCommand();

        $placeholders = [
            '%command.name%',
            '%command.full_name%',
        ];
        $replacements = [
            $name,
            $isSingleCommand ? $_SERVER['PHP_SELF'] : $_SERVER['PHP_SELF'].' '.$name,
        ];

        return str_replace($placeholders, $replacements, $this->getHelp() ?: $this->getDescription());
    }
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);
    }