Examples of ArgParser

argparser.ArgParser
te holder objects for storing results ... DoubleHolder theta = new DoubleHolder(); StringHolder fileName = new StringHolder(); BooleanHolder debug = new BooleanHolder(); // create the parser and specify the allowed options ... ArgParser parser = new ArgParser("java argparser.SimpleExample"); parser.addOption ("-theta %f #theta value (in degrees)", theta); parser.addOption ("-file %s #name of the operating file", fileName); parser.addOption ("-debug %v #enables display of debugging info", debug); // match the arguments ... parser.matchAllArgs (args); // and print out the values System.out.println ("theta=" + theta.value); System.out.println ("fileName=" + fileName.value); System.out.println ("debug=" + debug.value); }
A command line specifying all three options might look like this:
```
 java argparser.SimpleExample -theta 7.8 -debug -file /ai/lloyd/bar  
```
The application creates an instance of ArgParser and then adds descriptions of the allowed options using {@link #addOption addOption}. The method {@link #matchAllArgs(String[]) matchAllArgs} is then used to matchthese options against the command line arguments. Values associated with each option are returned in the value field of special ``holder'' classes (e.g., {@link argparser.DoubleHolder DoubleHolder}, {@link argparser.StringHolder StringHolder}, etc.).
The first argument to {@link #addOption addOption} is a string thatspecifies (1) the option's name, (2) a conversion code for its associated value (e.g., %f for floating point, %s for a string, %v for a boolean flag), and (3) an optional description (following the # character) which is used for generating help messages. The second argument is the holder object through which the value is returned. This may be either a type-specific object (such as {@link argparser.DoubleHolder DoubleHolder} or {@link argparser.StringHolder StringHolder}), an array of the appropriate type, or an instance of java.util.Vector.
By default, arguments that don't match the specified options, are out of range, or are otherwise formatted incorrectly, will cause matchAllArgs to print a message and exit the program. Alternatively, an application can use {@link #matchAllArgs(String[],int,int) matchAllArgs(args,idx,exitFlags)} to obtainan array of unmatched arguments which can then be processed separately
Range Specification
The values associated with options can also be given range specifications. A range specification appears in curly braces immediately following the conversion code. In the code fragment below, we show how to specify an option -name that expects to be provided with one of three string values (john, mary, or jane), an option -index that expects to be supplied with a integer value in the range 1 to 256, an option -size that expects to be supplied with integer values of either 1, 2, 4, 8, or 16, and an option -foo that expects to be supplied with floating point values in the ranges -99 < foo <= -50, or 50 <= foo < 99.
```
 StringHolder name = new StringHolder(); IntHolder index = new IntHolder(); IntHolder size = new IntHolder(); DoubleHolder foo = new DoubleHolder(); parser.addOption ("-name %s {john,mary,jane}", name); parser.addOption ("-index %d {[1,256]}", index); parser.addOption ("-size %d {1,2,4,8,16}", size); parser.addOption ("-foo %f {(-99,-50],[50,99)}", foo); 
```
If an argument value does not lie within a specified range, an error is generated.
Multiple Option Names
An option may be given several names, or aliases, in the form of a comma seperated list:
```
 parser.addOption ("-v,--verbose %v #print lots of info"); parser.addOption ("-of,-outfile,-outputFile %s #output file"); 
```
Single Word Options
Normally, options are assumed to be "multi-word", meaning that any associated value must follow the option as a separate argument string. For example,
```
 parser.addOption ("-file %s #file name"); 
```
will cause the parser to look for two strings in the argument list of the form
```
 -file someFileName 
```
However, if there is no white space separting the option's name from it's conversion code, then values associated with that option will be assumed to be part of the same argument string as the option itself. For example,
```
 parser.addOption ("-file=%s #file name"); 
```
will cause the parser to look for a single string in the argument list of the form
```
 -file=someFileName 
```
Such an option is called a "single word" option.
In cases where an option has multiple names, then this single word behavior is invoked if there is no white space between the last indicated name and the conversion code. However, previous names in the list will still be given multi-word behavior if there is white space between the name and the following comma. For example,
```
 parser.addOption ("-nb=,-number ,-n%d #number of blocks"); 
```
will cause the parser to look for one, two, and one word constructions of the forms
```
 -nb=N -number N -nN 
```
Multiple Option Values
If may be useful for an option to be followed by several values. For instance, we might have an option -velocity which should be followed by three numbers denoting the x, y, and z components of a velocity vector. We can require multiple values for an option by placing a multiplier specification, of the form XN, where N is an integer, after the conversion code (or range specification, if present). For example,
```
 double[] pos = new double[3]; addOption ("-position %fX3 #position of the object", pos); 
```
will cause the parser to look for
```
 -position xx yy zz 
```
in the argument list, where xx, yy, and zz are numbers. The values are stored in the array pos. Options requiring multiple values must use arrays to return their values, and cannot be used in single word format.
Multiple Option Invocation
Normally, if an option appears twice in the command list, the value associated with the second instance simply overwrites the value associated with the first instance. However, the application can instead arrange for the storage of all values associated with multiple option invocation, by supplying a instance of java.util.Vector to serve as the value holder. Then every time the option appears in the argument list, the parser will create a value holder of appropriate type, set it to the current value, and store the holder in the vector. For example, the construction
```
 Vector vec = new Vector(10); parser.addOption ("-foo %f", vec); parser.matchAllArgs(args); 
```
when supplied with an argument list that contains
```
 -foo 1.2 -foo 1000 -foo -78 
```
will create three instances of {@link argparser.DoubleHolder DoubleHolder}, initialized to 1.2, 1000, and -78, and store them in vec.
Generating help information
ArgParser automatically generates help information for the options, and this information may be printed in response to a help option, or may be queried by the application using {@link #getHelpMessage getHelpMessage}. The information for each option consists of the option's name(s), it's required value(s), and an application-supplied description. Value information is generated automaticlly from the conversion code, range, and multiplier specifications (although this can be overriden, as described below). The application-supplied description is whatever appears in the specification string after the optional # character. The string returned by {@link #getHelpMessage getHelpMessage} forthe first example above would be
```
 Usage: java argparser.SimpleExample Options include: -help,-?                displays help information -theta <float>          theta value (in degrees) -file <string>          name of the operating file -debug                  enables display of debugging info 
```
The options -help and -? are including in the parser by default as help options, and they automatically cause the help message to be printed. To exclude these options, one should use the constructor {@link #ArgParser(String,boolean) ArgParser(synopsis,false)}. Help options can also be specified by the application using {@link #addOption addOption} and the conversion code %h. Help optionscan be disabled using {@link #setHelpOptionsEnabled setHelpOptionsEnabled(false)}.
A description of the required values for an option can be specified explicitly by placing a second # character in the specification string. Everything between the first and second # characters then becomes the value description, and everything after the second # character becomes the option description. For example, if the -theta option above was specified with
```
 parser.addOption ("-theta %f #NUMBER#theta value (in degrees)",theta); 
```
instead of
```
 parser.addOption ("-theta %f #theta value (in degrees)", theta); 
```
then the corresponding entry in the help message would look like
```
 -theta NUMBER          theta value (in degrees) 
```
Custom Argument Parsing
An application may find it necessary to handle arguments that don't fit into the framework of this class. There are a couple of ways to do this.
First, the method {@link #matchAllArgs(String[],int,int) matchAllArgs(args,idx,exitFlags)} returns an array ofall unmatched arguments, which can then be handled specially:
```
 String[] unmatched = parser.matchAllArgs (args, 0, parser.EXIT_ON_ERROR); for (int i = 0; i < unmatched.length; i++) { ... handle unmatched arguments ... } 
```
For instance, this would be useful for an applicatoon that accepts an arbitrary number of input file names. The options can be parsed using matchAllArgs, and the remaining unmatched arguments give the file names.
If we need more control over the parsing, we can parse arguments one at a time using {@link #matchArg matchArg}:
```
 int idx = 0; while (idx < args.length) { try { idx = parser.matchArg (args, idx); if (parser.getUnmatchedArgument() != null) { ... handle this unmatched argument ourselves ... } } catch (ArgParserException e)  { // malformed or erroneous argument parser.printErrorAndExit (e.getMessage()); } } 
```
{@link #matchArg matchArg(args,idx)} matches one option at locationidx in the argument list, and then returns the location value that should be used for the next match. If an argument does not match any option, {@link #getUnmatchedArgument getUnmatchedArgument} will return a copy of theunmatched argument.
Reading Arguments From a File
The method {@link #prependArgs prependArgs} can be used to automaticallyread in a set of arguments from a file and prepend them onto an existing argument list. Argument words correspond to white-space-delimited strings, and the file may contain the comment character # (which comments out everything to the end of the current line). A typical usage looks like this:
```
 ... create parser and add options ... args = parser.prependArgs (new File(".configFile"), args); parser.matchAllArgs (args); 
```
This makes it easy to generate simple configuration files for an application. @author John E. Lloyd, Fall 2004
com.bbn.openmap.util.ArgParser
A simple class to manage the line arguments of a program. Takes the String[] argv that is provided to the main method of a class, and separates them out, depending on the options given to the ArgParser. After you create the parser, add your options that you want.
com.persistit.util.ArgParser

A simple command line argument parser that provides primitive type conversion and value checking. An application passes a template and the command line argument array to the constructor of this class. The constructor validates the argument list. Subsequently the application can access specific fields from the command line using the ArgParser's accessor methods.

If the command line includes the argument -? then ArgParser displays a summary of permissible arguments and sets its UsageOnly property to true. The calling application should simply exit if isUsageonly is true for the constructed ArgParser.
@author peter @version 1.0
dijjer.util.ArgParser

org.python.core.ArgParser

A utility class for handling mixed positional and keyword arguments. A typical usage:

 public MatchObject search(PyObject[] args, String[] kws) { ArgParser ap = new ArgParser("search", args, kws, "pattern", "pos", "endpos"); String string = ap.getString(0); int start     = ap.getInt(1, 0); int end       = ap.getInt(2, string.length()); ...

Examples of org.python.core.ArgParser

        int argc = args.length - keywords.length;
        if (argc > 2) {
            throw Py.TypeError("register_dialect() expected at most 2 arguments, got " + argc);
        }


        ArgParser ap = parseArgs("register_dialect", args, keywords);
        PyObject name = ap.getPyObject(0);
        PyObject dialect = ap.getPyObject(1, null);


        if (!(name instanceof PyBaseString)) {
            throw Py.TypeError("dialect name must be a string or unicode");
        }

View Full Code Here

Examples of org.python.core.ArgParser

    public static PyObject list_dialects() {
        return _dialects.keys();
    }


    public static PyObject reader(PyObject[] args, String[] keywords) {
        ArgParser ap = parseArgs("reader", args, keywords);
        PyObject iterator = Py.iter(ap.getPyObject(0), "argument 1 must be an iterator");
        PyObject dialect = ap.getPyObject(1, null);
        return new PyReader(iterator, dialectFromKwargs(dialect, args, keywords));
    }

View Full Code Here

Examples of org.python.core.ArgParser

        PyObject dialect = ap.getPyObject(1, null);
        return new PyReader(iterator, dialectFromKwargs(dialect, args, keywords));
    }


    public static PyObject writer(PyObject[] args, String[] keywords) {
        ArgParser ap = parseArgs("writer", args, keywords);
        PyObject outputFile = ap.getPyObject(0);
        PyObject dialect = ap.getPyObject(1, null);


        PyObject writeline = outputFile.__findattr__("write");
        if (writeline == null || !writeline.isCallable()) {
            throw Py.TypeError("argument 1 must have a \"write\" method");
        }

View Full Code Here

0 1 2 3 4 5

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.