org.apache.commons.cli

Class PosixParser

Implemented Interfaces:
CommandLineParser

public class PosixParser
extends Parser

The class PosixParser provides an implementation of the flatten method.

Version:
$Revision: 1.11 $

Author:
John Keyes (john at integralsource.com)

See Also:
Parser

Field Summary

private Option
currentOption
holder for the current option
private boolean
eatTheRest
specifies if bursting should continue
private Options
options
the command line Options
private ArrayList
tokens
holder for flattened tokens

Fields inherited from class org.apache.commons.cli.Parser

cmd, options, requiredOptions

Method Summary

protected void
burstToken(String token, boolean stopAtNonOption)
Breaks token into its constituent parts using the following algorithm.
protected String[]
flatten(Options options, String[] arguments, boolean stopAtNonOption)
An implementation of Parser's abstract flatten method.
private void
gobble(Iterator iter)
Adds the remaining tokens to the processed tokens list.
private void
init()
Resets the members to their original state i.e.
private void
process(String value)
If there is a current option and it can have an argument value then add the token to the processed tokens list and set the current option to null.
private void
processOptionToken(String token, boolean stopAtNonOption)
If an Option exists for token then set the current option and add the token to the processed list.
private void
processSingleHyphen(String hyphen)
If it is a hyphen then add the hyphen directly to the processed tokens list.

Methods inherited from class org.apache.commons.cli.Parser

checkRequiredOptions, flatten, parse, parse, processArgs, processOption

Field Details

currentOption

private Option currentOption
holder for the current option


eatTheRest

private boolean eatTheRest
specifies if bursting should continue


options

private Options options
the command line Options


tokens

private ArrayList tokens
holder for flattened tokens

Method Details

burstToken

protected void burstToken(String token,
                          boolean stopAtNonOption)
Breaks token into its constituent parts using the following algorithm.
  • ignore the first character ("-" )
  • foreach remaining character check if an Option exists with that id.
  • if an Option does exist then add that character prepended with "-" to the list of processed tokens.
  • if the Option can have an argument value and there are remaining characters in the token then add the remaining characters as a token to the list of processed tokens.
  • if an Option does NOT exist AND stopAtNonOption IS set then add the special token "--" followed by the remaining characters and also the remaining tokens directly to the processed tokens list.
  • if an Option does NOT exist AND stopAtNonOption IS NOT set then add that character prepended with "-".


flatten

protected String[] flatten(Options options,
                           String[] arguments,
                           boolean stopAtNonOption)
An implementation of Parser's abstract flatten method.

The following are the rules used by this flatten method.

  1. if stopAtNonOption is true then do not burst anymore of arguments entries, just add each successive entry without further processing. Otherwise, ignore stopAtNonOption.
  2. if the current arguments entry is "--" just add the entry to the list of processed tokens
  3. if the current arguments entry is "-" just add the entry to the list of processed tokens
  4. if the current arguments entry is two characters in length and the first character is "-" then check if this is a valid Option id. If it is a valid id, then add the entry to the list of processed tokens and set the current Option member. If it is not a valid id and stopAtNonOption is true, then the remaining entries are copied to the list of processed tokens. Otherwise, the current entry is ignored.
  5. if the current arguments entry is more than two characters in length and the first character is "-" then we need to burst the entry to determine its constituents. For more information on the bursting algorithm see burstToken.
  6. if the current arguments entry is not handled by any of the previous rules, then the entry is added to the list of processed tokens.
Overrides:
flatten in interface Parser

Parameters:
options - The command line Options
arguments - The command line arguments to be parsed
stopAtNonOption - Specifies whether to stop flattening when an non option is found.

Returns:
The flattened arguments String array.


gobble

private void gobble(Iterator iter)
Adds the remaining tokens to the processed tokens list.

Parameters:
iter - An iterator over the remaining tokens


init

private void init()
Resets the members to their original state i.e. remove all of tokens entries, set eatTheRest to false and set currentOption to null.


process

private void process(String value)
If there is a current option and it can have an argument value then add the token to the processed tokens list and set the current option to null.

If there is a current option and it can have argument values then add the token to the processed tokens list.

If there is not a current option add the special token "--" and the current value to the processed tokens list. The add all the remaining argument values to the processed tokens list.

Parameters:
value - The current token


processOptionToken

private void processOptionToken(String token,
                                boolean stopAtNonOption)
If an Option exists for token then set the current option and add the token to the processed list.

If an Option does not exist and stopAtNonOption is set then ignore the current token and add the remaining tokens to the processed tokens list directly.

Parameters:
token - The current option token
stopAtNonOption - Specifies whether flattening should halt at the first non option.


processSingleHyphen

private void processSingleHyphen(String hyphen)
If it is a hyphen then add the hyphen directly to the processed tokens list.

Parameters:
hyphen - The hyphen token