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 com.bbn.openmap.util.ArgParser

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


        try {


            ArgParser ap = new ArgParser("SimpleHttpImageServer");
            ap.add("properties",
                    "A URL to use to set the properties for the ImageServer.",
                    1);
            ap.add("port",
                    "The port to listen for new map image requests on. (Default 0)",
                    1);
            ap.add("verbose", "Print action messages.");
            ap.add("test", "Create a test default image.");


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


            String proparg[];
            PropertyHandler propHandler;
            proparg = ap.getArgValues("properties");
            if (proparg != null) {
                propHandler = new PropertyHandler(proparg[0]);
            } else {
                propHandler = new PropertyHandler();
            }


            String[] varg = ap.getArgValues("verbose");
            if (varg != null) {
                Debug.put("shis");
                Debug.put("imageserver");
            }


            SimpleHttpImageServer shis;
            String[] portarg = ap.getArgValues("port");
            if (portarg != null) {
                int port = Integer.parseInt(portarg[0]);
                shis = new SimpleHttpImageServer(port, false, propHandler.getProperties());
            } else {
                shis = new SimpleHttpImageServer(propHandler.getProperties());
            }


            Debug.output("OpenMap SimpleHttpImageServer: listening on port: "
                    + shis.httpd.getPort()
                    + (proparg == null ? "" : " with properties in "
                            + proparg[0]));


            String[] testarg = ap.getArgValues("test");
            if (testarg != null) {
                OutputStream out = new FileOutputStream("test.jpg");
                shis.httpRequest(new HttpRequestEvent(shis, "/openmap?REQUEST=map", out));
            }

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

    }


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


        ArgParser ap = new ArgParser("SymbolChooser");
        ap.add("type",
                "Type of symbol image set being used (PNG, GIF or SVG, PNG is default)",
                1);
        ap.add("path",
                "Path to root directory of symbol image set if not in classpath",
                1);
        ap.add("default", "15 character code for default icon", 1);
        ap.add("verbose", "Print messages");


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


        String arg[];
        arg = ap.getArgValues("type");
        String symbolImageMakerClass = "com.bbn.openmap.tools.symbology.milStd2525.PNGSymbolImageMaker";
        if (arg != null) {
            if (arg[0].equalsIgnoreCase("SVG")) {
                symbolImageMakerClass = "com.bbn.openmap.tools.symbology.milStd2525.SVGSymbolImageMaker";
            } else if (arg[0].equalsIgnoreCase("GIF")) {
                symbolImageMakerClass = "com.bbn.openmap.tools.symbology.milStd2525.GIFSymbolImageMaker";
            }
        }


        String defaultSymbolCode = "SFPPV-----*****";
        arg = ap.getArgValues("default");
        if (arg != null) {
            defaultSymbolCode = arg[0];
        }


        arg = ap.getArgValues("verbose");
        if (arg != null) {
            Debug.put("symbology");
        }


        SymbolReferenceLibrary srl = new SymbolReferenceLibrary();
        if (srl.setSymbolImageMaker(symbolImageMakerClass) != null) {


            arg = ap.getArgValues("path");
            if (arg != null) {
                srl.getSymbolImageMaker().setDataPath(arg[0]);
            }


            SymbolChooser.showDialog(null,

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

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


        ArgParser ap = new ArgParser("MakeToc");
        ap.add("absolute",
                "Use absolute paths in A.TOC - Use for multiple RPF Directories");
        ap.add("boundary", "Maximum frames on a boundary edge (Default 200)", 1);
        ap.add("dchum", "DCHUM files are included.");
        ap.add("log", "Pathname of log file to list A.TOC creation output.", 1);
        ap.add("output",
                "Path to directory to place A.TOC file. (Default is current directory)",
                1);
        ap.add("producer",
                "The producer of the frames (Default DMAAC).  Five letter code.",
                1);
        ap.add("verbose", "Print out progress");
        ap.add("extraverbose", "Print out ALL progress");
        ap.add("nw",
                "Don't put up swing progress window (Use this if you are getting weird exceptions)");
        ap.add("paths",
                "Space separated paths to RPF directory or directories.  Should be last.  If more than one directory is listed, then absolute paths are used in the A.TOC file.",
                ArgParser.TO_END);


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


        String outputFile = "." + File.separator
                + RpfTocHandler.RPF_TOC_FILE_NAME;


        String arg[];
        arg = ap.getArgValues("output");
        if (arg != null) {
            outputFile = arg[0] + File.separator
                    + RpfTocHandler.RPF_TOC_FILE_NAME;
        }


        arg = ap.getArgValues("log");
        if (arg != null) {
            String logfile = arg[0];
            Debug.directOutput(logfile, false, true);
            Debug.output("MakeToc: Creating log at " + logfile + " at "
                    + java.util.Calendar.getInstance().getTime());
        }


        arg = ap.getArgValues("dchum");
        if (arg != null) {
            Dchum = true;
        }


        arg = ap.getArgValues("verbose");
        if (arg != null) {
            Debug.put("maketoc");
        }


        arg = ap.getArgValues("extraverbose");
        if (arg != null) {
            Debug.put("maketoc");
            Debug.put("maketocdetail");
        }


        String[] paths = null;
        arg = ap.getArgValues("paths");
        if (arg != null) {
            paths = arg;
        } else {
            paths = ap.getRest();
        }


        if (paths == null || paths.length == 0) {
            Debug.output("MakeToc: need a path to start searching for RPF frames.");
            System.exit(0);
        }


        MakeToc mt = new MakeToc();


        // If the -nw argument was not used, add a progress gauge.
        arg = ap.getArgValues("nw");
        if (arg == null) {
            try {
                mt.addProgressListener(new com.bbn.openmap.gui.ProgressListenerGauge("RPF A.TOC File Creation"));
            } catch (RuntimeException re) {


            }
        }


        boolean argFlagged = false;
        arg = ap.getArgValues("absolute");
        if (arg != null) {
            argFlagged = true;
        }


        arg = ap.getArgValues("producer");
        if (arg != null) {
            mt.setProducer(arg[0]);
        }


        if (paths.length > 1 || argFlagged) {
            Debug.output("MakeToc:  creating A.TOC with absolute path names.");
            mt.setRelativeFramePaths(false);
        }


        arg = ap.getArgValues("boundary");
        int max_side = DEFAULT_MAX_SIDE;
        if (arg != null) {
            try {
                max_side = Integer.parseInt(arg[0]);
                if (max_side <= DEFAULT_MAX_SIDE) {

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser


    }


    public static void main(String[] argv) {
        Debug.init();
        ArgParser argp = new ArgParser("GeoIntersectionLayer");


        argp.add("shape", "Shape file to use for GeoRegions in index.", 1);


        argp.parse(argv);
        String[] files = argp.getArgValues("shape");
        if (files != null && files.length > 0 && files[0].endsWith(".shp")) {
            File file = new File(files[0]);


            GeoIntersectionLayer gil = new GeoIntersectionLayer();
            Debug.output("Loading shape file: " + file.getName());
            long startTime = System.currentTimeMillis();
            gil.addShapeFile(file);
            long endTime = System.currentTimeMillis();


            Debug.output(" time to load file: " + (endTime - startTime) + " ms");


            gil.runGeoTests(25, 3);
            
        } else {
            argp.printUsage();
            System.exit(0);
        }
    }

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

        return model;
    }


    public static void main(String[] args) {
        Debug.init();
        ArgParser ap = new ArgParser("DbfFile");
        ap.add("columns", "Print field header information.");
        ap.add("mask", "Only show listed columns", -1);
        ap.add("source", "The dbf file to read.", 1);
        ap.add("target",
                "The dbf file to write, use with mask to remove columns into new dbf file.",
                1);
        ap.add("num",
                "Specify the number of records to read and display (handy for large dbf files)",
                1);


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


        String source = null;
        String target = null;
        double num = Double.MAX_VALUE;


        String[] ags = ap.getArgValues("source");
        if (ags != null) {
            source = ags[0];
        } else {
            source = FileUtils.getFilePathToOpenFromUser("Choose DBF file");
            if (source == null) {
                System.exit(0);
            }
        }


        ags = ap.getArgValues("target");
        if (ags != null) {
            target = ags[0];
        }


        boolean readData = ap.getArgValues("columns") == null;


        if (!readData) {
            num = 0;
        } else {
            ags = ap.getArgValues("num");
            if (ags != null) {
                try {
                    num = Double.parseDouble(ags[0]);
                } catch (NumberFormatException nfe) {
                }
            }
        }


        String[] columnMask = ap.getArgValues("mask");
        String[] columns = ap.getArgValues("columns");


        try {


            DbfFile dtm = (DbfFile) DbfFile.getDbfTableModel(source);

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);


        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...");

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

    /**
     * The main OpenMap application.
     */
    static public void main(String args[]) {


        ArgParser ap = new ArgParser("OpenMap");
        String propArgs = null;
        ap.add("properties",
                "A resource, file path or URL to properties file\n Ex: http://myhost.com/xyz.props or file:/myhome/abc.pro\n See Java Documentation for java.net.URL class for more details",
                1);


        ap.parse(args);


        String[] arg = ap.getArgValues("properties");
        if (arg != null) {
            propArgs = arg[0];
        }


        OpenMap.create(propArgs);

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     * Run DTEDAdmin from the command line.
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("DTEDAdmin");
        ap.add("boundary", "upper lat, left lon, lower lat, right lon", 4, true);
        ap.add("copy", "Copy files to DTED directory.", 1);
        ap.add("level",
                "DTED level to consider (0, 1, 2), 0 is default.  Needs to be set for other levels.",
                1);
        ap.add("outside", "Use files outside boundary.");
        ap.add("query", "Print out files that meet parameters.");
        ap.add("remove", "Delete DTED files.");
        ap.add("source", "The source DTED directory path.", 1);
        ap.add("verbose", "Print out progress.");


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


        String arg[];
        String sourceDir = null;


        arg = ap.getArgValues("source");
        if (arg != null) {
            sourceDir = arg[0];
        }


        boolean inside = true;
        arg = ap.getArgValues("outside");
        if (arg != null) {
            inside = false;
        }


        int level = 0;
        arg = ap.getArgValues("level");
        if (arg != null) {
            try {
                level = Integer.parseInt(arg[0]);
            } catch (NumberFormatException nfe) {
                level = 0;
            }
        }


        arg = ap.getArgValues("verbose");
        if (arg != null) {
            Debug.put("dted");
        }


        DTEDAdmin admin = null;
        double ullat = 89;
        double ullon = -180;
        double lrlat = -90;
        double lrlon = 179;


        arg = ap.getArgValues("boundary");
        if (arg != null) {
            try {
                ullat = Double.parseDouble(arg[0]);
                ullon = Double.parseDouble(arg[1]);
                lrlat = Double.parseDouble(arg[2]);
                lrlon = Double.parseDouble(arg[3]);
            } catch (NumberFormatException nfe1) {
                Debug.error("DTEDAdmin: boundary coordinates not valid:\n"
                        + "  " + arg[0] + "\n  " + arg[1] + "\n  " + arg[2]
                        + "\n  " + arg[3]);
                System.exit(0);
            }
        }


        if (sourceDir != null) {
            admin = new DTEDAdmin(sourceDir, ullat, ullon, lrlat, lrlon, level, inside, DTEDAdmin.DTED_EQUAL_LEVELS);
        }


        arg = ap.getArgValues("copy");
        if (arg != null) {
            if (admin != null) {
                admin.copyTo(arg[0]);
            } else {
                Debug.error("DTEDAdmin:  frame parameters not set for copy.  Need source directory");
                System.exit(0);
            }
        }


        arg = ap.getArgValues("query");
        if (arg != null) {
            if (admin != null) {
                Debug.output("DTED frame files found:");
                admin.query();
            } else {
                Debug.error("DTEDAdmin:  frame parameters not set for query.  Need source directory");
                System.exit(0);
            }
        }


        arg = ap.getArgValues("remove");
        if (arg != null) {
            if (admin != null) {
                Debug.output("These files will be deleted:");
                admin.query();
                Debug.output("Are you sure you want to delete them? [y/N]");

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("DTEDLocator");


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


        DTEDLocator locator = new DTEDLocator();


        // Assume that the arguments are paths to directories or

View Full Code Here

Examples of com.bbn.openmap.util.ArgParser

     * .dbf files) and writes them back out.
     */
    public static void main(String[] argv) {
        Debug.init();


        ArgParser ap = new ArgParser("EsriShapeExport");
        ap.add("shp", "A URL to a shape file (.shp).", 1);


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


        ap.parse(argv);


        String[] files = ap.getArgValues("shp");
        if (files != null && files[0] != null) {
            String shp = files[0];
            String dbf = null;


            try {
                dbf = shp.substring(0, shp.lastIndexOf('.') + 1) + PARAM_DBF;


                DbfTableModel model = DbfTableModel.getDbfTableModel(PropUtils.getResourceOrFileOrURL(dbf));
                EsriGraphicList list = EsriGraphicList.getEsriGraphicList(PropUtils.getResourceOrFileOrURL(shp),
                        null,
                        null);


                Debug.output(list.getDescription());


                EsriShapeExport ese = new EsriShapeExport(list, model, null);
                ese.export();


            } catch (MalformedURLException murle) {
                Debug.error("EsriShapeExport: Malformed URL Exception\n"
                        + murle.getMessage());
            } catch (NullPointerException npe) {
                Debug.error("EsriShapeExport: Path to shape file isn't good enough to find .dbf file and .shx file.");
            } catch (Exception exception) {
                Debug.error("EsriShapeExport: Exception\n"
                        + exception.getMessage());
                exception.printStackTrace();
            }


        } else {
            ap.bail("Need a path to a Shape file (.shp)", true);
        }
        System.exit(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.