| java.lang.Object
 org.netbeans.spi.sendopts.Option
| Option | | final public class Option (Code) | | Represents possible option that can appear on
org.netbeans.api.sendopts.CommandLine and contains factory methods to create them.
An option can have letter short version, long name. It can
accept arguments, one argument or an array of additional arguments.
author:
Jaroslav Tulach |
| Method Summary | |
| public static Option | additionalArguments(char shortName, String longName)
Creates an option that can accept additional arguments .
For example to have option that opens few files
one could write:
Option openOption = Option.additionalArguments('o', "open");
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(openOption)) {
for (String fileName : values.get(openOption)) {
File file = new File(
Env.getCurrentDirectory , fileName);
// do what is necessary
}
}
}
The values map always contains the openOption
if it appeared on the command line. | | public static Option | always()
Creates an option that is always present. | | public static Option | defaultArguments()
Creates a default option that accepts additional arguments
not claimed by any other option. | | public static Option | displayName(Option option, String bundleName, String key)
Associates a name with given option. | | public boolean | equals(Object o)
Options with the same functionality, regardless of their descriptions
Option.shortDescription and
Option.displayName are always the same. | | public int | hashCode()
| | public static Option | optionalArgument(char shortName, String longName)
Factory method for option that may, but does not need to have an argument.
For example to have option that increments by one or by specified number
one could write:
Option incrementOption = Option.optionalArgument('i', "increment");
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(incrementOption)) {
String[] inc = values.get(incrementOption);
int increment = inc == null ? 1 : Integer.parseInt(inc[0]);
// do what is necessary
}
}
The values map always contains the incrementOption
if it appeared on the command line. | | public static Option | requiredArgument(char shortName, String longName)
Factory method for option has to be followed by one argument.
For example to have option that opens a file
one could write:
Option openOption = Option.optionalArgument('o', "open");
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(openOption)) {
String fileName = values.get(openOption)[0];
File file = new File(
Env.getCurrentDirectory , fileName);
// do what is necessary
}
}
The values map always contains the openOption
if it appeared on the command line. | | public static Option | shortDescription(Option option, String bundleName, String key)
Associates a short textual description with given option. | | public String | toString()
Programmatic textual representation of the option. | | public static Option | withoutArgument(char shortName, String longName)
Factory method that creates an option without any arguments. |
| NO_SHORT_NAME | | final public static char NO_SHORT_NAME(Code) | | Constant that represents no short name indicator.
|
| additionalArguments | | public static Option additionalArguments(char shortName, String longName)(Code) | | Creates an option that can accept additional arguments .
For example to have option that opens few files
one could write:
Option openOption = Option.additionalArguments('o', "open");
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(openOption)) {
for (String fileName : values.get(openOption)) {
File file = new File(
Env.getCurrentDirectory , fileName);
// do what is necessary
}
}
}
The values map always contains the openOption
if it appeared on the command line. Its value is then always string
array of arbitrary length containing all elements on the command line
that were not recognised as options (or their arguments).
For example line
X.java -o Y.java Z.txt
will invoke the
OptionProcessor with
{ "X.java", "Y.java", "Z.txt" }.
Obviously only one such
Option.additionalArguments can be
used at once on a command line. If there was not only the open
but also edit option
taking the additional arguments,
then command line like:
--edit X.java --open Y.java Z.txt
would be rejected.
Parameters:
shortName - the character to be used as a shortname or Option.NO_SHORT_NAME
Parameters:
longName - the long name or null |
| always | | public static Option always()(Code) | | Creates an option that is always present. This can be useful for
processors that want to be notified everytime the command line
is successfuly parsed.
Option always = Option.always();
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
assert values.contains(always);
}
the option that always matches correct command line
since:
2.1 |
| defaultArguments | | public static Option defaultArguments()(Code) | | Creates a default option that accepts additional arguments
not claimed by any other option.
For example to have option that opens few files
one could write:
Option openOption = Option.defaultArguments();
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(openOption)) {
for (fileName : values.get(openOption)) {
File file = new File(
Env.getCurrentDirectory , fileName);
// do what is necessary
}
}
}
The values map always contains the openOption
if there were some arguments on the command line that were not parsed
by any other option. Its value is then always string
array of arbitrary length containing all elements on the command line
that were not recognised as options (or their arguments).
For example line
X.java Y.java Z.txt
will invoke the
OptionProcessor with
{ "X.java", "Y.java", "Z.txt" }.
Obviously only one such
Option.defaultArguments can defined.
If there are two, then an error is reported when one tries to parse
any command line with arguments not claimed by any other option.
That is why it is always good idea to not define just
Option.defaultArguments option, but also appropriate
Option.additionalArguments one:
Option openOption1 = Option.defaultArguments();
Option openOption2 = Option.additionalArguments('o', "open");
and handle both of them in the
OptionProcessor . Then if the
command line:
X.java Y.java Z.txt is rejected due to ambiguities one can use
X.java Y.java --open Z.txt to invoke the same functionality.
|
| displayName | | public static Option displayName(Option option, String bundleName, String key)(Code) | | Associates a name with given option. By default
the option display name is generated by the infrastructure from the
short and long name plus generic description of options arguments, this
method allows to completely replace the default behaviour.
Parameters:
option - the option to add description for
Parameters:
bundleName - name of a bundle to create
Parameters:
key - the bundle key to get the message from option with same behaviour as the old one plus with associated display name |
| hashCode | | public int hashCode()(Code) | | |
| optionalArgument | | public static Option optionalArgument(char shortName, String longName)(Code) | | Factory method for option that may, but does not need to have an argument.
For example to have option that increments by one or by specified number
one could write:
Option incrementOption = Option.optionalArgument('i', "increment");
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(incrementOption)) {
String[] inc = values.get(incrementOption);
int increment = inc == null ? 1 : Integer.parseInt(inc[0]);
// do what is necessary
}
}
The values map always contains the incrementOption
if it appeared on the command line. If it had associated value, then
the map.get(incrementOption) returns array of length one,
with item on position 0 being the value of the option. However if the
option appeared without argument, then the value associated with the
option is null.
If registered into to system using
OptionProcessor then users could
use command lines like -i=5 or --increment=5 to
increase the value by five or just -i and --increment
to increment by default - e.g. one.
Parameters:
shortName - the character to be used as a shortname or Option.NO_SHORT_NAME
Parameters:
longName - the long name or null |
| requiredArgument | | public static Option requiredArgument(char shortName, String longName)(Code) | | Factory method for option has to be followed by one argument.
For example to have option that opens a file
one could write:
Option openOption = Option.optionalArgument('o', "open");
and inside of the
OptionProcessor declaring this
option use:
public void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(openOption)) {
String fileName = values.get(openOption)[0];
File file = new File(
Env.getCurrentDirectory , fileName);
// do what is necessary
}
}
The values map always contains the openOption
if it appeared on the command line. Its value is then always string
array of length one and its 0 element contains the argument for the
option.
If registered into to system using
OptionProcessor then users could
use command lines like -oX.java or --open Y.java to
invoke the open functionality.
Parameters:
shortName - the character to be used as a shortname or Option.NO_SHORT_NAME
Parameters:
longName - the long name or null |
| shortDescription | | public static Option shortDescription(Option option, String bundleName, String key)(Code) | | Associates a short textual description with given option. This message
is going to be printed during
org.netbeans.api.sendopts.CommandLine.usage next to the
option name. Usually should be one liner comment.
Parameters:
option - the option to add description for
Parameters:
bundleName - name of a bundle to create
Parameters:
key - the bundle key to get the message from option with same behaviour as the old one plus with associated short description message |
| toString | | public String toString()(Code) | | Programmatic textual representation of the option. Format is subject to change
in future.
textual description of the option |
| withoutArgument | | public static Option withoutArgument(char shortName, String longName)(Code) | | Factory method that creates an option without any arguments.
For example to create an option that handles --help or
-h one can create it using:
Option helpOption = Option.withoutArgument('h', "help");
and inside of the
OptionProcessor declaring this
option use:
protected void process(Env env, Map<Option,String[]> values) throws CommandException {
if (values.containsKey(helpOption)) {
printHelp(env.getErrorStream());
}
}
The values.get(helpOption) is always null to signal
that this options does not have any associated value.
Parameters:
shortName - character code or Option.NO_SHORT_NAME
Parameters:
longName - long name or null option representing the created definition |
|
|