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 argparser.ArgParser

   * @param args
   *            The command line arguments.
   */
  public Main(String[] args)
    {
        final ArgParser parser = new ArgParser("java -jar venn.jar <arguments>");
        
        BooleanHolder   versionOpt = new BooleanHolder();
        
        StringHolder    configFile = new StringHolder(),
                        outConfigFile = new StringHolder(),
                        listFile = new StringHolder(),
                        gceFile = new StringHolder(),
                        seFile = new StringHolder(),
                        htGceFile = new StringHolder(),
                        filterFile = new StringHolder(),
                        optStateFile = new StringHolder(),
                        outFilterFile = new StringHolder(),
                        svgFile = new StringHolder(),
                        simFile = new StringHolder(),
                        profFile = new StringHolder();
     
        // create the parser and specify the allowed options ...
        parser.addOption("--version,-v %v #show VennMaster version", versionOpt);
        parser.addOption("--cfg %s #input configuration file", configFile); 
        parser.addOption("--ocfg %s #output configuration file", outConfigFile);
        parser.addOption("--list %s #list input file", listFile);
        parser.addOption("--gce %s #GoMiner gene-category export file", gceFile);
        parser.addOption("--se %s #GoMiner summary export file", seFile);
        parser.addOption("--htgce %s #High-Throughput GoMiner gce file", htGceFile);
        parser.addOption("--filter %s #gene filter for GoMinor import.", filterFile);
        parser.addOption("--ofilter %s #output filter file", outFilterFile);
        parser.addOption("--optstate %s #output of the optimizer state",optStateFile);
        parser.addOption("--svg %s #generates an SVG file of the Venn diagram", svgFile);
        parser.addOption("--sim %s #output of the simulation profile",simFile);
        parser.addOption("--prof %s #output of the final error profile",profFile);
        
        parser.matchAllArgs(args);
        
        System.out.println( "VennMaster version "+
                            Constants.VERSION_MAJOR+"."+Constants.VERSION_MINOR+"."+Constants.VERSION_SUB+"  ("+Constants.VERSION_DATE+")");
        if( versionOpt.value )
        {

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

    }


    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("MGRSPoint");
        ap.add("mgrs", "Print Latitude and Longitude for MGRS value", 1);
        ap.add("latlon",
                "Print MGRS for Latitude and Longitude values",
                2,
                true);
        ap.add("sets", "Print the MGRS 100k table");
        ap.add("altsets", "Print the MGRS 100k table for the Bessel ellipsoid");
        ap.add("rtc",
                "Run test case, with filename and input data type [MGRS | UTM | LatLon]",
                2);


        if (!ap.parse(argv)) {
            ap.printUsage();
            System.exit(0);
        }


        String arg[];
        arg = ap.getArgValues("sets");
        if (arg != null) {
            new MGRSPoint().print100kSets();
        }


        arg = ap.getArgValues("altsets");
        if (arg != null) {
            MGRSPoint mgrsp = new MGRSPoint();
            mgrsp.setOriginColumnLetters(BESSEL_SET_ORIGIN_COLUMN_LETTERS);
            mgrsp.setOriginRowLetters(BESSEL_SET_ORIGIN_ROW_LETTERS);
            mgrsp.print100kSets();
        }


        arg = ap.getArgValues("mgrs");
        if (arg != null) {
            try {
                MGRSPoint mgrsp = new MGRSPoint(arg[0]);
                Debug.output(arg[0] + " is " + mgrsp.toLatLonPoint());
            } catch (NumberFormatException nfe) {
                Debug.error(nfe.getMessage());
            }
        }


        arg = ap.getArgValues("latlon");
        if (arg != null) {
            try {


                float lat = Float.parseFloat(arg[0]);
                float lon = Float.parseFloat(arg[1]);


                LatLonPoint llp = new LatLonPoint(lat, lon);
                MGRSPoint mgrsp = LLtoMGRS(llp);
                UTMPoint utmp = LLtoUTM(llp);


                if (utmp.zone_letter == 'Z') {
                    Debug.output(llp + "to UTM: latitude limit exceeded.");
                } else {
                    Debug.output(llp + " is " + utmp);
                }


                Debug.output(llp + " is " + mgrsp);


            } catch (NumberFormatException nfe) {
                Debug.error("The numbers provided:  " + argv[0] + ", "
                        + argv[1] + " aren't valid");
            }
        }


        arg = ap.getArgValues("rtc");
        if (arg != null) {
            runTests(arg[0], arg[1]);
        }


    }

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     *        statement.
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("Wanderer");


        if (argv.length == 0) {
            ap.bail("", true);
        }


        String[] dirs = argv;


        Wanderer wanderer = new Wanderer(new TestWandererCallback());

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     *        usage statement.
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("Purge");


        if (argv.length == 0) {
            ap.bail("Wanders through directory tree pruning '~' files.\nUsage: java com.bbn.openmap.util.wanderer.Purge <dir>",
                    false);
        }


        Purge purge = new Purge(new String[] { ".#" }, new String[] { "~" });

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     *        usage statement.
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("SVG2GIF");
        ap.add("dimension",
                "Dimension of output image, add height and width arguments separated by a space",
                2);


        if (argv.length == 0) {
            ap.bail("Usage: java com.bbn.openmap.util.wanderer.SVG <dir> (-help for options)",
                    false);
        }


        ap.parse(argv);


        Dimension dim = null;
        String[] arg = ap.getArgValues("dimension");
        if (arg != null) {


            String heightString = arg[0];
            String widthString = arg[1];


            Debug.output("Creating images with height (" + heightString
                    + ") width (" + widthString + ")");
            try {
                int width = Integer.parseInt(widthString);
                int height = Integer.parseInt(heightString);
                dim = new Dimension(width, height);
            } catch (NumberFormatException nfe) {
                String message = "Problem reading dimensions: " + nfe.getMessage();
                ap.bail(message, false);
            }
        }


        String[] dirs = ap.getRest();


        SVG2GIF svg2gif = new SVG2GIF();
        if (dim != null) {
            svg2gif.setDimension(dim);
        }

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     *        usage statement.
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("SLOC");


        if (argv.length == 0) {
            ap.bail("Counts ';' and '}' to sum up Source Lines Of Code\nUsage: java com.bbn.openmap.util.wanderer.SLOC <dir>",
                    false);
        }


        ap.parse(argv);


        String[] dirs = argv;


        SLOC sloc = new SLOC();
        Wanderer wanderer = new Wanderer(sloc);

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

    /**
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("OneWaySync");
        ap.add("source",
                "The source directory to copy files and directories from.",
                1);
        ap.add("target",
                "The target directory to receive the updated files and directories.",
                1);
        ap.add("verbose",
                "Announce all changes, failures will still be reported.");
        ap.add("fakeit",
                "Just print what would happen, don't really do anything.");
        ap.add("report",
                "Print out what didn't get copied, and what files exist only on the target side.");


        if (argv.length < 4) {
            ap.bail("", true);
        }


        ap.parse(argv);


        boolean verbose = false;
        String[] verb = ap.getArgValues("verbose");
        if (verb != null) {
            verbose = true;
        }


        boolean fakeit = false;
        verb = ap.getArgValues("fakeit");
        if (verb != null) {
            verbose = true;
            fakeit = true;
        }


        boolean report = false;
        verb = ap.getArgValues("report");
        if (verb != null) {
            report = true;
        }


        String[] sourceDir;
        sourceDir = ap.getArgValues("source");
        if (sourceDir != null || sourceDir.length < 1) {
            if (verbose)
                Debug.output("Source directory is " + sourceDir[0]);
        } else {
            ap.bail("OneWaySync needs path to source directory", false);
        }


        String[] targetDir;
        targetDir = ap.getArgValues("target");
        if (targetDir != null || targetDir.length < 1) {
            if (verbose)
                Debug.output("Target directory is " + targetDir[0]);
        } else {
            ap.bail("OneWaySync needs path to source directory", false);
        }


        OneWaySync cc = new OneWaySync(sourceDir[0], targetDir[0]);
        cc.setVerbose(verbose);
        cc.setFakeit(fakeit);

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     */
    public static void main(String[] argv) {
        Debug.init();
        boolean toUpper = true;


        ArgParser ap = new ArgParser("ChangeCase");
        ap.add("upper",
                "Change file and directory names to UPPER CASE (default). <path> <path> ...",
                ArgParser.TO_END);
        ap.add("lower",
                "Change file and directory names to lower case. <path> <path> ...",
                ArgParser.TO_END);
        ap.add("verbose",
                "Announce all changes, failures will still be reported.");


        if (argv.length == 0) {
            ap.bail("", true);
        }


        ap.parse(argv);


        String[] dirs;
        dirs = ap.getArgValues("lower");
        if (dirs != null) {
            Debug.output("Converting to lower case names...");
            toUpper = false;
        } else {
            dirs = ap.getArgValues("upper");
            // No arguments given, going to default.
            if (dirs == null) {
                dirs = argv;
            }
            Debug.output("Converting to UPPER CASE names...");
        }


        boolean verbose = false;
        String[] verboseTest = ap.getArgValues("verbose");
        if (verboseTest != null) {
            verbose = true;
        }


        ChangeCase cc = new ChangeCase(toUpper);

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

    }


    public static void main(String[] args) {
        Debug.init();


        ArgParser ap = new ArgParser("EsriGraphicList");
        ap.add("fixcl", "Check and fix content length of Shape file", 1);
        ap.add("print", "Display text structure of shapes in Shape file", 1);


        if (!ap.parse(args)) {
            ap.printUsage();
            System.exit(0);
        }


        String[] fixit = ap.getArgValues("fixcl");
        if (fixit != null) {
            String shape = fixit[0];
            if (shape.endsWith(".shp")) {
                shape = shape.substring(0, shape.length() - 4);


                try {
                    URL shx = PropUtils.getResourceOrFileOrURL(shape + ".shx");
                    InputStream is = shx.openStream();
                    ShxInputStream pis = new ShxInputStream(is);
                    int[][] index = pis.getIndex();
                    is.close();
                    
                    RandomAccessFile raf = new RandomAccessFile(shape + ".shp", "rw");
                    raf.seek(24);
                    int contentLength = raf.readInt();
                    
                    int indexedContentLength = index[0][index[0].length - 1] + index[1][index[1].length - 1];
                    
                    if (contentLength != indexedContentLength) {
                        System.out.println(shape + " content length - shp: " + contentLength + ", shx: " + indexedContentLength);
                        raf.seek(24);
                        raf.writeInt(indexedContentLength);
                    }
                    raf.close();
                    
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
            } else {
                System.out.println("Shape " + shape
                        + " doesn't look like a shape file");
            }
        }


        String[] printit = ap.getArgValues("print");
        if (printit != null) {
            try {


                URL eglURL = PropUtils.getResourceOrFileOrURL(printit[0]);
                EsriGraphicList egl = EsriGraphicList.getEsriGraphicList(eglURL,

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     * 
     * @param args
     */
    public static void main(String[] args) {
        Debug.init();
        ArgParser ap = new ArgParser("RpfUtil");
        ap.add("copy",
                "Copy RPF data from one RPF directory to another. (-copy from to)",
                2);
        ap.add("delete",
                "Delete RPF data from a RPF directory. (-delete from)",
                1);
        ap.add("maketoc",
                "Create an A.TOC file in a RPF directory. (-maketoc from).",
                1);
        ap.add("zip",
                "Create a zip file from a RPF directory. (-zip zipFileName from)",
                2);
        ap.add("query",
                "Print the paths of files that fit the criteria, but do nothing",
                1);
        ap.add("scale",
                "The scale to use for criteria in matching chart types, followed by a letter describing the relationship of matching frame scales to give scale ('g'reater than, 'l'ess than, 'n'ot equal to, 'e'qual to). (optional)",
                2);
        ap.add("boundary",
                "Coordinates of bounding box (upper lat, left lon, lower lat, right lon) (optional)",
                4,
                true);
        ap.add("inside",
                "Flag to manage RPF frames inside bounding box. (default, optional)");
        ap.add("outside",
                "Flag to manage RPF frames outside bounding box. (optional)");
        ap.add("verbose", "Print out progress");
        ap.add("extraverbose", "Print out ALL progress");


        if (!ap.parse(args)) {
            ap.printUsage();
            System.exit(0);
        }


        float ulat = 90f;
        float llat = -90f;
        float llon = -180f;
        float rlon = 180f;


        String arg[];
        arg = ap.getArgValues("boundary");
        if (arg != null) {
            boolean boundaryCoordinateProblem = true;
            try {
                ulat = Float.parseFloat(arg[0]);
                llon = Float.parseFloat(arg[1]);
                llat = Float.parseFloat(arg[2]);
                rlon = Float.parseFloat(arg[3]);


                boundaryCoordinateProblem = ulat > 90 || llon < -180
                        || llat < -90 || rlon > 180 || ulat <= llat
                        || llon >= rlon;


            } catch (NumberFormatException nfe) {
                Debug.error("Parsing error for boundary coordinates");
            }


            if (boundaryCoordinateProblem) {
                Debug.error("Boundary coordinates are screwy...");
                ap.printUsage();
                System.exit(0);
            }
        }


        RpfUtil rpfUtil = new RpfUtil(ulat, llon, llat, rlon);


        rpfUtil.verbose = (ap.getArgValues("verbose") != null);


        arg = ap.getArgValues("outside");
        if (arg != null) {
            rpfUtil.setBoundaryLimits(RpfUtil.OUTSIDE);
        }


        arg = ap.getArgValues("inside");
        if (arg != null) {
            rpfUtil.setBoundaryLimits(RpfUtil.INSIDE);
        }


        arg = ap.getArgValues("scale");
        if (arg != null) {
            try {
                rpfUtil.setScale(Float.parseFloat(arg[0]));
                rpfUtil.setScaleDelim(arg[1].charAt(0));
            } catch (NumberFormatException nfe) {
                Debug.error("Scale value is screwy...");
                ap.printUsage();
                System.exit(0);
            }
        }


        arg = ap.getArgValues("query");
        if (arg != null) {
            rpfUtil.query(arg[0]);
            System.exit(0);
        }


        arg = ap.getArgValues("copy");
        if (arg != null) {
            rpfUtil.setRpfDir(arg[0]);
            if (!rpfUtil.copy(arg[1])) {
                Debug.output("Problem copying frames");
            }
        }


        arg = ap.getArgValues("delete");
        if (arg != null && !rpfUtil.delete(arg[0])) {
            Debug.output("Problem deleting files.");
        }


        arg = ap.getArgValues("maketoc");
        if (arg != null && !rpfUtil.maketoc(arg[0])) {
            Debug.output("Problem creating A.TOC file for frames.");
        }


        arg = ap.getArgValues("zip");
        if (arg != null && !rpfUtil.zip(arg[0], arg[1])) {
            Debug.output("Problem creating zip file: " + arg[0]);
        }
    }

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.