Laboratoire ICAR » Plateforme TXM

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>org.txm.libs.args4j</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.ManifestBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

		<buildCommand>

			<name>org.eclipse.pde.SchemaBuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.pde.PluginNature</nature>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package org.kohsuke.args4j;

import java.lang.reflect.AccessibleObject;

import java.net.URL;

import org.kohsuke.args4j.spi.ArgumentImpl;

import org.kohsuke.args4j.spi.ConfigElement;

import org.kohsuke.args4j.spi.OptionImpl;

import org.kohsuke.args4j.spi.Setters;

import org.xml.sax.InputSource;

/**

 * Parses an XML-file specifying the 'annotations'.

 * The XML must have the structure:

 * <pre>

 * <args>

 *     <option field="" method="" name="" usage="" metavar="" handler=""/>

 *     <argument field="" method="" usage="" metavar="" handler=""/>

 * </args>

 * </pre>

 * Exactly one of the attributes 'field' or 'method' must be set.

 * The 'handler' value specifies a full qualified class name.

 *

 * <h3>Example</h3>

 * <pre>

 * <args>

 *     <option field="recursive" name="-r" usage="recursively run something"/>

 *     <option field="out" name="-o" usage="output to this file" metavar="OUTPUT"/>

 *     <option method="setStr(String)" name="-str"/>

 *     <option field="data" name="-custom" handler="org.kohsuke.args4j.spi.BooleanOptionHandler" usage="boolean value for checking the custom handler"/>

 *     <argument field="arguments"/>

 * <args>

 * </pre>

 *

 * @author Jan Materne

 */

public class XmlParser {

    public void parse(URL xml, CmdLineParser parser, Object bean) {

        parse(new InputSource(xml.toExternalForm()),parser,bean);

    }

	public void parse(InputSource xml, CmdLineParser parser, Object bean) {

		try {

			Config config = Config.parse(xml);

			for(ConfigElement ce : config.options) {

				Option option = new OptionImpl(ce);

                parser.addOption(Setters.create(parser, findMethodOrField(bean, ce.field, ce.method),bean), option);

			}

			for (ConfigElement ce : config.arguments) {

				Argument argument = new ArgumentImpl(ce);

				parser.addArgument(Setters.create(parser, findMethodOrField(bean, ce.field, ce.method),bean), argument);

			}

		} catch (Exception e) {

			throw new RuntimeException(Messages.METADATA_ERROR.format(), e);

		}

	}

	/**

	 * Finds a {@link java.lang.reflect.Method} or {@link java.lang.reflect.Method} in the bean

	 * instance with the requested name.

	 * @param bean    bean instance

	 * @param field   name of the field (field XOR method must be specified)

	 * @param method  name of the method (field XOR method must be specified)

	 * @return the reflection reference

	 * @throws SecurityException

	 * @throws NoSuchFieldException

	 * @throws NoSuchMethodException

	 * @throws ClassNotFoundException

	 */

	private AccessibleObject findMethodOrField(Object bean, String field, String method) throws SecurityException, NoSuchFieldException, NoSuchMethodException, ClassNotFoundException {

		AccessibleObject rv;

		if (field != null) {

			rv = bean.getClass().getDeclaredField(field);

		} else {

			String methodName = method.substring(0, method.indexOf("("));

			String[] params = method.substring(method.indexOf("(")+1, method.indexOf(")")).split(",");

			Class[] paramTypes = new Class[params.length];

			for(int i=0; i<params.length; i++) {

				String className = params[i];

				if (className.indexOf('.') < 0) {

					className = "java.lang." + className;

				}

				paramTypes[i] = Class.forName(className);

			}

			rv = bean.getClass().getMethod(methodName, paramTypes);

		}

		return rv;

	}

}

package org.kohsuke.args4j;

/**

 * Signals an incorrect use of args4j annotations.

 *

 * <p>

 * This only happens when there's something wrong with the way you use

 * args4j in your code, not when the arguments supplied by the user is

 * wrong. Hence this class is an {@link Error}.

 *

 * @author Kohsuke Kawaguchi

 */

public class IllegalAnnotationError extends Error {

	private static final long serialVersionUID = 2397757838147693218L;

	public IllegalAnnotationError(String message) {

        super(message);

    }

    public IllegalAnnotationError(String message, Throwable cause) {

        super(message, cause);

    }

    public IllegalAnnotationError(Throwable cause) {

        super(cause);

    }

}

<html><body>

<p>Core classes of the Args4J command line parser.</p>

<h1>What is Args4J</h1>

<p>Args4J is a command line parser. As such a parser its job is to parse the String-array passed to the main() method

and transfer the values to a java object, which includes type conversion. The entry point into this parsing is

the CmdLineParser class with its parse() Method.</p>

<p>Args4J must know the mapping between the flag from the command line and the target for the value.

There are multiple ways for Args4J: <ul>

    <li>place an @Option or @Argument annotation at a setter or on a field</li>

    <li>provide a XML configuration file</li>

    <li>make all fields public available</li>

</ul> 

depending on what you want, you have to do a configuration step before starting the parsing.</p>

<h1>Examples</h1>

<p><tt>java Main -text newText</tt></p>

<p>The standard use case is having a bean class and providing the annotations.

This feature is available since the first Args4J release:

<!-- TODO: 

Javadoc stops when reaching the at-sign. When I load the package.html directly into Firefox,

all is fine. But when creating the javadoc it stops copying the content at that sign.

(a) is a compromise here ...

Does anyone know how to handle that?

-->

<pre>

public class Bean {

    (a)Option(name="-text")

    String text;

}

public class Main {

    public static void main(String[] args) throws CmdLineException {

        Object bean = new Bean();

        CmdLineParser parser = new CmdLineParser(bean);

        parser.parse(args);

    }

}

</pre>

<p>An easy way for initializing fields and not touching the bean source code

is using the FieldParser. The FieldParser scans all fields of the bean class

(including inheritance) and makes them public available as options with 

a '-' prefix in the name.

This feature is available since Args4J release 2.0.16:

<pre>

public class Bean {

    String text;

}

public class Main {

    public static void main(String[] args) throws CmdLineException {

        Object bean = new Bean();

        CmdLineParser parser = new CmdLineParser(null);

        new FieldParser().parse(parser, bean);

        parser.parse(args);

    }

}

</pre>

<p>While the FieldParser is easier to use, the XmlParser supports more features. 

That said it supports all features which are available via annotations: usage text, specifying handlers and more.

You have to provide an XML InputSource or an URL to the XML file. 

This feature is available since Args4J release 2.0.16:

<pre>

public class Bean {

    String text;

}

public class Main {

    public static void main(String[] args) throws CmdLineException {

        Object bean = new Bean();

        CmdLineParser parser = new CmdLineParser(null);

        new XmlParser().parse(getClass().getResource(bean.getClass().getName() + ".xml"), parser, bean);

        parser.parse(args);

    }

}

<args>

  <option field="text" name="-text" usage="Output text"/>

</args>

</pre>

</p>

</body></html>

package org.kohsuke.args4j;

import java.lang.annotation.Retention;

import java.lang.annotation.Target;

import org.kohsuke.args4j.spi.OptionHandler;

import static java.lang.annotation.RetentionPolicy.RUNTIME;

import static java.lang.annotation.ElementType.FIELD;

import static java.lang.annotation.ElementType.METHOD;

import static java.lang.annotation.ElementType.PARAMETER;

/**

 * Argument of the command line.

 *

 * This works mostly like {@link Option} except the following differences.

 *

 * <ol>

 *  <li>Arguments have an index about their relative position on the command line.

 * </ol>

 * 

 * @author Kohsuke Kawaguchi

 * @author Mark Sinke

 */

@Retention(RUNTIME)

@Target({FIELD,METHOD,PARAMETER})

public @interface Argument {

    /**

     * See {@link Option#usage()}.

     */

    String usage() default ""; //$NON-NLS-1$

    /**

     * See {@link Option#metaVar()}.

     */

    String metaVar() default ""; //$NON-NLS-1$

    /**

     * See {@link Option#required()}.

     */

    boolean required() default false;

    /**

     * See {@link Option#handler()}.

     */

    Class<? extends OptionHandler> handler() default OptionHandler.class;

    /**

     * Position of the argument.

     *

     * <p>

     * If you define multiple single value properties to bind to arguments,

     * they should have index=0, index=1, index=2, ... and so on.

     *

     * <p>

     * Multi value properties bound to arguments must be always the last entry.

     */

    int index() default 0;

    /**

     * See {@link Option#multiValued()}.

     */

    boolean multiValued() default false;

}

package org.kohsuke.args4j;

import org.kohsuke.args4j.spi.MethodSetter;

import org.kohsuke.args4j.spi.Setters;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

/**

 * Parser for analyzing Args4J annotations in the class hierarchy.

 *

 * This can be used to feed option bindings that span across multiple instances.

 *

 * @author Jan Materne

 */

public class ClassParser {

    public void parse(Object bean, CmdLineParser parser) {

        // recursively process all the methods/fields.

        for( Class c=bean.getClass(); c!=null; c=c.getSuperclass()) {

            for( Method m : c.getDeclaredMethods() ) {

                Option o = m.getAnnotation(Option.class);

                if(o!=null) {

                	parser.addOption(new MethodSetter(parser,bean,m), o);

                }

                Argument a = m.getAnnotation(Argument.class);

                if(a!=null) {

                    parser.addArgument(new MethodSetter(parser,bean,m), a);

                }

            }

            for( Field f : c.getDeclaredFields() ) {

                Option o = f.getAnnotation(Option.class);

                if(o!=null) {

                	parser.addOption(Setters.create(f,bean),o);

                }

                Argument a = f.getAnnotation(Argument.class);

                if(a!=null) {

                	parser.addArgument(Setters.create(f,bean), a);

                }

            }

        }

	}

}

MISSING_OPERAND = \

    Option "{0}" takes an operand

UNDEFINED_OPTION = \

    "{0}" is not a valid option

NO_ARGUMENT_ALLOWED = \

    No argument is allowed: {0}

REQUIRED_OPTION_MISSING = \

    Option "{0}" is required

REQUIRED_ARGUMENT_MISSING = \

    Argument "{0}" is required

TOO_MANY_ARGUMENTS = \

    Too many arguments: {0}

METADATA_ERROR = \

    Problems while reading the args-confguration.

MULTIPLE_USE_OF_ARGUMENT = \

    Argument with index {0} is used more than once

MULTIPLE_USE_OF_OPTION = \

    Option name {0} is used more than once

UNKNOWN_HANDLER = \

    No OptionHandler is registered to handle {0}

NO_OPTIONHANDLER = \

    Not an OptionHandler class

NO_CONSTRUCTOR_ON_HANDLER = \

    {0} does not have the proper constructor

FORMAT_ERROR_FOR_MAP = \

    An argument for setting a Map must contain a "="

UNDEFINNED_WIDGET = \

    Undefined widget {0}. Choose between {1}

MAP_HAS_NO_KEY = \

    A key must be set.

package org.kohsuke.args4j;

import java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

/**

 * Starter class which uses reflection to instantiate the business

 * class, parse the command line parameters, sets the fields of the

 * business class and doing the help message handling.

 *  

 * @author Jan Materne

 */

public class Starter {

	/**

	 * The name of the JavaVM property which stores the class name of

	 * the business class.

	 * {@value} 

	 */

	public static final String PARAMETER_NAME = "mainclass";

	public static void main(String[] args) {

		String classname = System.getProperty(PARAMETER_NAME);

		CmdLineParser parser = null;

		boolean classHasArgument = false;

		boolean classHasOptions  = false;

		// Check the requirement: must specify the class to start

		if (classname == null || "".equals(classname)) {

			System.err.println("The system property '" 

					+ PARAMETER_NAME

					+ "' must contain the classname to start.");

		}

		try {

			Class clazz = Class.forName(classname);

			Object bean = clazz.newInstance();

			parser = new CmdLineParser(bean);

			// for help output

			classHasArgument = hasAnnotation(clazz, Argument.class);

			classHasOptions  = hasAnnotation(clazz, Option.class);

			parser.parseArgument(args);

			// try starting   run()

			Method m;

			boolean couldInvoke = false;

			try {

				m = clazz.getMethod("run", (Class[]) null);

				m.invoke(bean, (Object[]) null);

				couldInvoke = true;

			} catch (SecurityException e) {

			} catch (IllegalArgumentException e) {

			} catch (NoSuchMethodException e) {

			} catch (IllegalAccessException e) {

			} catch (InvocationTargetException e) {

			}

			// try starting   run(String[])

			if (!couldInvoke) try {

				m = clazz.getMethod("run", String[].class);		

				m.invoke(bean, new Object[]{args});

				couldInvoke = true;

			} catch (SecurityException e) {

			} catch (IllegalArgumentException e) {

				e.printStackTrace();

			} catch (NoSuchMethodException e) {

			} catch (IllegalAccessException e) {

			} catch (InvocationTargetException e) {

			}

		} catch (ClassNotFoundException e) {

			// wrong classpath setting

			System.err.println("Cant find the class '" 

					+ classname

					+ "' as specified in the system property '"

					+ PARAMETER_NAME + "'.");

		} catch (CmdLineException e) {

			// wrong argument enteres, so print the usage message as

			// supplied by args4j

			System.err.println(e.getMessage());

			System.err.print(classname);

			if (classHasOptions)  System.err.print(" [options]");

			if (classHasArgument) System.err.print(" arguments");

			System.err.println();

			if (parser != null)

				parser.printUsage(System.err);

		} catch (Exception e) {

			// Must be an unhandled business exception, so we can only

			// print stacktraces.

			e.printStackTrace();

		}

	}

	public static boolean hasAnnotation(Class clazz, Class<? extends Annotation> annotation) {

		if (clazz.getAnnotation(annotation)!=null) return true;

		for (Field f : clazz.getFields()) {

			if (f.getAnnotation(annotation)!=null) return true;

		}

		for (Method m : clazz.getMethods()) {

			if (m.getAnnotation(annotation)!=null) return true;

		}

		return false;

	}

}

package org.kohsuke.args4j;

import org.kohsuke.args4j.spi.OptionHandler;

/**

 * Run-time copy of the Option or Argument annotation. By definition, unnamed options

 * are arguments (and instances of this class). Named options are actually a subclass.

 * 

 * @author Mark Sinke

 */

public class OptionDef {

	private final String usage;

	private final String metaVar;

	private final boolean required;

	private final boolean multiValued;

	private final Class<? extends OptionHandler> handler;

	public OptionDef(Argument a, boolean forceMultiValued) {

		this(a.usage(), a.metaVar(), a.required(), a.handler(), a.multiValued() || forceMultiValued);

	}

	protected OptionDef(String usage, String metaVar, boolean required,

			Class<? extends OptionHandler> handler, boolean multiValued) {

		this.usage = usage;

		this.metaVar = metaVar;

		this.required = required;

		this.handler = handler;

		this.multiValued = multiValued;

	}

	public String usage() {

		return usage;

	}

	public String metaVar() {

		return metaVar;

	}

	public boolean required() {

		return required;

	}

	public Class<? extends OptionHandler> handler() {

		return handler;

	}

	public boolean isMultiValued() {

		return multiValued;

	}

	public boolean isArgument() {

		return true;

	}

	@Override

	public String toString() {

		return metaVar() != null ? metaVar() : "ARG"; //$NON-NLS-1$

	}

}

package org.kohsuke.args4j;

import java.io.File;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.Writer;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.net.URI;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.TreeMap;

import java.util.logging.Logger;

import org.kohsuke.args4j.spi.BooleanOptionHandler;

import org.kohsuke.args4j.spi.ByteOptionHandler;

import org.kohsuke.args4j.spi.CharOptionHandler;

import org.kohsuke.args4j.spi.DateOptionHandler;

import org.kohsuke.args4j.spi.DoubleOptionHandler;

import org.kohsuke.args4j.spi.EnumOptionHandler;

import org.kohsuke.args4j.spi.FileOptionHandler;

import org.kohsuke.args4j.spi.FloatOptionHandler;

import org.kohsuke.args4j.spi.IntOptionHandler;

import org.kohsuke.args4j.spi.LongOptionHandler;

import org.kohsuke.args4j.spi.MapOptionHandler;

import org.kohsuke.args4j.spi.ObjectOptionHandler;

import org.kohsuke.args4j.spi.OptionHandler;

import org.kohsuke.args4j.spi.Parameters;

import org.kohsuke.args4j.spi.QueryOptionHandler;

import org.kohsuke.args4j.spi.Setter;

import org.kohsuke.args4j.spi.ShortOptionHandler;

import org.kohsuke.args4j.spi.StringOptionHandler;

import org.kohsuke.args4j.spi.URIOptionHandler;

import org.kohsuke.args4j.spi.URLOptionHandler;

import org.txm.searchengine.cqp.corpus.query.Query;

/**

 * Command line argument owner.

 *

 * <p>

 * For a typical usage, see <a href="https://args4j.dev.java.net/source/browse/args4j/args4j/examples/SampleMain.java?view=markup">this example</a>.

 *

 * @author

 *     Kohsuke Kawaguchi (kk@kohsuke.org)

 */

public class CmdLineParser {

    /**

     * Discovered {@link OptionHandler}s for options.

     */

    private final List<OptionHandler> options = new ArrayList<OptionHandler>();

    /**

     * Discovered {@link OptionHandler}s for arguments.

     */

    private final List<OptionHandler> arguments = new ArrayList<OptionHandler>();

    private boolean parsingOptions = true;

    private OptionHandler currentOptionHandler = null;

	/**

	 *  The length of a usage line.

	 *  If the usage message is longer than this value, the parser

	 *  wraps the line. Defaults to 80.

	 */

	private int usageWidth = 80;

    /**

     * Creates a new command line owner that

     * parses arguments/options and set them into

     * the given object.

     *

     * @param bean

     *      instance of a class annotated by {@link Option} and {@link Argument}.

     *      this object will receive values. If this is null, the processing will

     *      be skipped, which is useful if you'd like to feed metadata from other sources.

     *

     * @throws IllegalAnnotationError

     *      if the option bean class is using args4j annotations incorrectly.

     */

    public CmdLineParser(Object bean) {

        // A 'return' in the constructor just skips the rest of the implementation

        // and returns the new object directly.

        if (bean==null) return;

        // Parse the metadata and create the setters

        new ClassParser().parse(bean,this);

        // for display purposes, we like the arguments in argument order, but the options in alphabetical order

        /*Collections.sort(options, new Comparator<OptionHandler>() {

			public int compare(OptionHandler o1, OptionHandler o2) {

				return o1.option.toString().compareTo(o2.option.toString());

			}

		});*/

    }

    /**

     * Programmatically defines an argument (instead of reading it from annotations like you normally do.)

     *

     * @param setter the setter for the type

     * @param a the Argument

     */

    public void addArgument(Setter setter, Argument a) {

        OptionHandler h = createOptionHandler(new OptionDef(a,setter.isMultiValued()),setter);

    	int index = a.index();

    	// make sure the argument will fit in the list

    	while (index >= arguments.size()) {

    		arguments.add(null);

    	}

    	if(arguments.get(index)!=null) {

            throw new IllegalAnnotationError(Messages.MULTIPLE_USE_OF_ARGUMENT.format(index));

        }

    	arguments.set(index,h);

    }

    /**

     * Programmatically defines an option (instead of reading it from annotations like you normally do.)

     *

     * @param setter the setter for the type

     * @param o the Option

     */

    public void addOption(Setter setter, Option o) {

        checkOptionNotInMap(o.name());

        checkWidgetNotInMap(o.widget());

        for (String alias : o.aliases()) {

        	checkOptionNotInMap(alias);

        }

        options.add(createOptionHandler(new NamedOptionDef(o, setter.isMultiValued()), setter));

    }

    public List<OptionHandler> getArguments() {

        return arguments;

    }

    public List<OptionHandler> getOptions() {

        return options;

    }

	private void checkOptionNotInMap(String name) throws IllegalAnnotationError {

		if(findOptionByName(name)!=null) {

            throw new IllegalAnnotationError(Messages.MULTIPLE_USE_OF_OPTION.format(name));

        }

	}

	public static List<String> widgets = Arrays.asList("Query", "Integer", "File", "CreateFile", "FileSave", "FileOpen", "Folder", "StringArray", "StringArrayMultiple", "StructuralUnits" , "String", "Text", "Float", "Boolean", "Date", "Date-Time");

	private void checkWidgetNotInMap(String widget) throws IllegalAnnotationError {

		if(!widgets.contains(widget)) {

            throw new IllegalAnnotationError(Messages.UNDEFINNED_WIDGET.format(widget, widgets));

        }

	}

    /**

     * Creates an {@link OptionHandler} that handles the given {@link Option} annotation

     * and the {@link Setter} instance.

     */

   @SuppressWarnings("unchecked")

    protected OptionHandler createOptionHandler(OptionDef o, Setter setter) {

        Constructor<? extends OptionHandler> handlerType;

        Class<? extends OptionHandler> h = o.handler();

        if(h==OptionHandler.class) {

            // infer the type

            // enum is the special case

            Class t = setter.getType();

            if(Enum.class.isAssignableFrom(t))

                return new EnumOptionHandler(this,o,setter,t);

            handlerType = handlerClasses.get(t);

            if(handlerType==null)

                throw new IllegalAnnotationError(Messages.UNKNOWN_HANDLER.format(t));

        } else {

            handlerType = getConstructor(h);

        }

        try {

            return handlerType.newInstance(this,o,setter);

        } catch (InstantiationException e) {

            throw new IllegalAnnotationError(e);

        } catch (IllegalAccessException e) {

            throw new IllegalAnnotationError(e);

        } catch (InvocationTargetException e) {

            throw new IllegalAnnotationError(e);

        }

    }

    /**

     * Formats a command line example into a string.

     *

     * See {@link #printExample(ExampleMode, ResourceBundle)} for more details.

     *

     * @param mode

     *      must not be null.

     * @return

     *      always non-null.

     */

    public String printExample(ExampleMode mode) {

        return printExample(mode,null);

    }

    /**

     * Formats a command line example into a string.

     *

     * <p>

     * This method produces a string like " -d <dir> -v -b",

     * which is useful for printing a command line example, perhaps

     * as a part of the usage screen.

     *

     *

     * @param mode

     *      One of the {@link ExampleMode} constants. Must not be null.

     *      This determines what option should be a part of the returned string.

     * @param rb

     *      If non-null, meta variables (<dir> in the above example)

     *      is treated as a key to this resource bundle, and the associated

     *      value is printed. See {@link Option#metaVar()}. This is to support

     *      localization.

     *

     *      Passing <tt>null</tt> would print {@link Option#metaVar()} directly.

     * @return

     *      always non-null. If there's no option, this method returns

     *      just the empty string "". Otherwise, this method returns a

     *      string that contains a space at the beginning (but not at the end.)

     *      This allows you to do something like:

     *

     *      <pre>System.err.println("java -jar my.jar"+parser.printExample(REQUIRED)+" arg1 arg2");</pre>

     */

    public String printExample(ExampleMode mode,ResourceBundle rb) {

        StringBuilder buf = new StringBuilder();

        for (OptionHandler h : options) {

            OptionDef option = h.option;

            if(option.usage().length()==0)  continue;   // ignore

            if(!mode.print(option))         continue;

            buf.append(' ');

            buf.append(h.getNameAndMeta(rb));

        }

        return buf.toString();

    }

    /**

     * Prints the list of options and their usages to the screen.

     *

     * <p>

     * This is a convenience method for calling {@code printUsage(new OutputStreamWriter(out),null)}

     * so that you can do {@code printUsage(System.err)}.

     */

    public void printUsage(OutputStream out) {

        printUsage(new OutputStreamWriter(out),null);

    }

    /**

     * Prints the list of options and their usages to the screen.

     *

     * @param rb

     *      if this is non-null, {@link Option#usage()} is treated

     *      as a key to obtain the actual message from this resource bundle.

     */

    public void printUsage(Writer out, ResourceBundle rb) {

        PrintWriter w = new PrintWriter(out);

        // determine the length of the option + metavar first

        int len = 0;

        for (OptionHandler h : arguments) {

            int curLen = getPrefixLen(h, rb);

            len = Math.max(len,curLen);

        }

        for (OptionHandler h: options) {

            int curLen = getPrefixLen(h, rb);

            len = Math.max(len,curLen);

        }

        // then print

        for (OptionHandler h : arguments) {

        	printOption(w, h, len, rb);

        }

        for (OptionHandler h : options) {

        	printOption(w, h, len, rb);

        }

        w.flush();

    }

    /**

     * Prints the usage information for a given option.

     * @param out      Writer to write into

     * @param handler  handler where to receive the informations

     * @param len      Maximum length of metadata column

     * @param rb       ResourceBundle for I18N

     */

    private void printOption(PrintWriter out, OptionHandler handler, int len, ResourceBundle rb) {

    	// Hiding options without usage information

    	if (handler.option.usage() == null || handler.option.usage().length() == 0) {

    		return;

    	}

    	// What is the width of the two data columns

    	int widthMetadata = Math.min(len, (usageWidth - 4) / 2);

    	int widthUsage    = usageWidth - 4 - widthMetadata;

    	// Line wrapping

    	List<String> namesAndMetas = wrapLines(handler.getNameAndMeta(rb), widthMetadata);

    	List<String> usages        = wrapLines(localize(handler.option.usage(),rb), widthUsage);

    	// Output

    	for(int i=0; i<Math.max(namesAndMetas.size(), usages.size()); i++) {

    		String nameAndMeta = (i >= namesAndMetas.size()) ? "" : namesAndMetas.get(i);

			String usage       = (i >= usages.size())        ? "" : usages.get(i);

			String format      = (nameAndMeta.length() > 0)

			                   ? " %1$-" + widthMetadata + "s : %2$-1s"

			                   : " %1$-" + widthMetadata + "s   %2$-1s";

			String output = String.format(format, nameAndMeta, usage);

			out.println(output);

    	}

    }

    private String localize(String s, ResourceBundle rb) {

        if(rb!=null)    return rb.getString(s);

        return s;

    }

    /**

     * Wraps a line so that the resulting parts are not longer than a given maximum length.

     * @param line       Line to wrap

     * @param maxLength  maximum length for the resulting parts

     * @return list of all wrapped parts

     */

    private List<String> wrapLines(String line, final int maxLength) {

    	List<String> rv = new ArrayList<String>();

        for (String restOfLine : line.split("\\n")) {

            while (restOfLine.length() > maxLength) {

                // try to wrap at space, but don't try too hard as some languages don't even have whitespaces.

                int lineLength;

                String candidate = restOfLine.substring(0, maxLength);

                int sp=candidate.lastIndexOf(' ');

                if(sp>maxLength*3/4)    lineLength=sp;

                else                    lineLength=maxLength;

                rv.add(restOfLine.substring(0, lineLength));

                restOfLine = restOfLine.substring(lineLength).trim();

            }

            rv.add(restOfLine);

        }

    	return rv;

    }

	private int getPrefixLen(OptionHandler h, ResourceBundle rb) {

		if(h.option.usage().length()==0)

			return 0;

		return h.getNameAndMeta(rb).length();

	}

    /**

     * Essentially a pointer over a {@link String} array.

     * Can move forward, can look ahead.

     */

    private class CmdLineImpl implements Parameters {

        private final String[] args;

        private int pos;

        CmdLineImpl( String[] args ) {

            this.args = args;

            pos = 0;

        }

        protected boolean hasMore() {

            return pos<args.length;

        }

        protected String getCurrentToken() {

            return args[pos];

        }

        private void proceed( int n ) {

            pos += n;

        }

        public String getParameter(int idx) throws CmdLineException {

			if( pos+idx>=args.length )

                throw new CmdLineException(CmdLineParser.this, Messages.MISSING_OPERAND.format(getOptionName()));

            return args[pos+idx];

        }

        public int size() {

            return args.length-pos;

        }

    }

    private String getOptionName() {

        return currentOptionHandler.option.toString();

    }

    /**

     * Same as {@link #parseArgument(String[])} 

     */

    public void parseArgument(Collection<String> args) throws CmdLineException {

        parseArgument(args.toArray(new String[args.size()]));

    }

    /**

     * Parses the command line arguments and set them to the option bean

     * given in the constructor.

     *

     * @param args arguments to parse

     *

     * @throws CmdLineException

     *      if there's any error parsing arguments, or if

     *      {@link Option#required() required} option was not given.

     */

    public void parseArgument(final String... args) throws CmdLineException {

        CmdLineImpl cmdLine = new CmdLineImpl(args);

        Set<OptionHandler> present = new HashSet<OptionHandler>();

        int argIndex = 0;

        while( cmdLine.hasMore() ) {

            String arg = cmdLine.getCurrentToken();

            if( isOption(arg) ) {

            	boolean isKeyValuePair = arg.indexOf('=')!=-1;

                // parse this as an option.

                currentOptionHandler = isKeyValuePair ? findOptionHandler(arg) : findOptionByName(arg);

                if(currentOptionHandler==null) {

                    // TODO: insert dynamic handler processing

                    throw new CmdLineException(this, Messages.UNDEFINED_OPTION.format(arg));

                }

                // known option; skip its name

                cmdLine.proceed(1);

            } else {

            	if (argIndex >= arguments.size()) {

            		Messages msg = arguments.size() == 0 ? Messages.NO_ARGUMENT_ALLOWED : Messages.TOO_MANY_ARGUMENTS;

                    throw new CmdLineException(this, msg.format(arg));

            	}

            	// known argument

            	currentOptionHandler = arguments.get(argIndex);

            	if (!currentOptionHandler.option.isMultiValued())

            		argIndex++;

            }

        	int diff = currentOptionHandler.parseArguments(cmdLine);

        	cmdLine.proceed(diff);

        	present.add(currentOptionHandler);

        }

        // make sure that all mandatory options are present

        for (OptionHandler handler : options)

            if(handler.option.required() && !present.contains(handler))

                throw new CmdLineException(this, Messages.REQUIRED_OPTION_MISSING.format(handler.option.toString()));

        // make sure that all mandatory arguments are present

        for (OptionHandler handler : arguments)

            if(handler.option.required() && !present.contains(handler))

                throw new CmdLineException(this, Messages.REQUIRED_ARGUMENT_MISSING.format(handler.option.toString()));

    }

	private OptionHandler findOptionHandler(String name) {

		OptionHandler handler = findOptionByName(name);

		if (handler==null) {

			// Have not found by its name, maybe its a property?

			// Search for parts of the name (=prefix) - most specific first

			for (int i=name.length(); i>1; i--) {

				String prefix = name.substring(0, i);

				Map<String,OptionHandler> possibleHandlers = filter(options, prefix);

				handler = possibleHandlers.get(prefix);

				if (handler!=null) return handler;

			}

		}

		return handler;

	}

	/**

	 * Finds a registered OptionHandler by its name or its alias.

	 * @param name name

	 * @return the OptionHandler or <tt>null</tt>

	 */

	private OptionHandler findOptionByName(String name) {

		for (OptionHandler h : options) {

			NamedOptionDef option = (NamedOptionDef)h.option;

			if (name.equals(option.name())) {

				return h;

			}

			for (String alias : option.aliases()) {

				if (name.equals(alias)) {

					return h;

				}

			}

		}

		return null;

	}

	private Map<String,OptionHandler> filter(List<OptionHandler> opt, String keyFilter) {

		Map<String,OptionHandler> rv = new TreeMap<String,OptionHandler>();

		for (OptionHandler h : opt) {

			if (opt.toString().startsWith(keyFilter)) rv.put(opt.toString(), h);

		}

		return rv;

	}

    /**

     * Returns true if the given token is an option

     * (as opposed to an argument.)

     */

    protected boolean isOption(String arg) {

        return parsingOptions && arg.startsWith("-");

    }

    /**

     * All {@link OptionHandler}s known to the {@link CmdLineParser}.

     *

     * Constructors of {@link OptionHandler}-derived class keyed by their supported types.

     */

    private static final Map<Class,Constructor<? extends OptionHandler>> handlerClasses =

            Collections.synchronizedMap(new HashMap<Class,Constructor<? extends OptionHandler>>());

    /**

     * Registers a user-defined {@link OptionHandler} class with args4j.

     *

     * <p>

     * This method allows users to extend the behavior of args4j by writing

     * their own {@link OptionHandler} implementation.

     *

     * @param valueType

     *      The specified handler is used when the field/method annotated by {@link Option}

     *      is of this type.

     * @param handlerClass

     *      This class must have the constructor that has the same signature as

     *      {@link OptionHandler#OptionHandler(CmdLineParser, OptionDef, Setter)}

     */

    public static void registerHandler( Class valueType, Class<? extends OptionHandler> handlerClass ) {

        if(valueType==null || handlerClass==null)

            throw new IllegalArgumentException();

        if(!OptionHandler.class.isAssignableFrom(handlerClass))

            throw new IllegalArgumentException(Messages.NO_OPTIONHANDLER.format());

        Constructor<? extends OptionHandler> c = getConstructor(handlerClass);

        handlerClasses.put(valueType,c);

    }

    private static Constructor<? extends OptionHandler> getConstructor(Class<? extends OptionHandler> handlerClass) {

        try {

            return handlerClass.getConstructor(CmdLineParser.class, OptionDef.class, Setter.class);

        } catch (NoSuchMethodException e) {

            throw new IllegalArgumentException(Messages.NO_CONSTRUCTOR_ON_HANDLER.format(handlerClass));

        }

    }

    static {

        registerHandler(Boolean.class,BooleanOptionHandler.class);

        registerHandler(boolean.class,BooleanOptionHandler.class);

        registerHandler(File.class,FileOptionHandler.class);

        registerHandler(URL.class, URLOptionHandler.class);

        registerHandler(URI.class, URIOptionHandler.class);

        registerHandler(Integer.class,IntOptionHandler.class);

        registerHandler(int.class,IntOptionHandler.class);

        registerHandler(Double.class, DoubleOptionHandler.class);

        registerHandler(double.class,DoubleOptionHandler.class);

        registerHandler(String.class,StringOptionHandler.class);

        registerHandler(Byte.class, ByteOptionHandler.class);

        registerHandler(byte.class, ByteOptionHandler.class);

        registerHandler(Character.class, CharOptionHandler.class);

        registerHandler(char.class, CharOptionHandler.class);

        registerHandler(Float.class, FloatOptionHandler.class);

        registerHandler(float.class, FloatOptionHandler.class);

        registerHandler(Long.class, LongOptionHandler.class);

        registerHandler(long.class, LongOptionHandler.class);

        registerHandler(Short.class, ShortOptionHandler.class);

        registerHandler(short.class, ShortOptionHandler.class);

        registerHandler(Date.class, DateOptionHandler.class);

        registerHandler(Query.class, QueryOptionHandler.class);

        registerHandler(Object.class, ObjectOptionHandler.class);

        // enum is a special case

        registerHandler(Map.class,MapOptionHandler.class);

    }

	public void setUsageWidth(int usageWidth) {

		this.usageWidth = usageWidth;

	}

	public void stopOptionParsing() {

		parsingOptions = false;

	}

    /**

     * Prints a single-line usage to the screen.

     *

     * <p>

     * This is a convenience method for calling {@code printUsage(new OutputStreamWriter(out),null)}

     * so that you can do {@code printUsage(System.err)}.

     */

	public void printSingleLineUsage(OutputStream out) {

		printSingleLineUsage(new OutputStreamWriter(out),null);

	}

    /**

     * Prints a single-line usage to the screen.

     *

     * @param rb

     *      if this is non-null, {@link Option#usage()} is treated

     *      as a key to obtain the actual message from this resource bundle.

     */

	public void printSingleLineUsage(Writer w, ResourceBundle rb) {

		PrintWriter pw = new PrintWriter(w);

		for (OptionHandler h : arguments) {

			printSingleLineOption(pw, h, rb);

		}

		for (OptionHandler h : options) {

			printSingleLineOption(pw, h, rb);

		}

		pw.flush();

	}

	private void printSingleLineOption(PrintWriter pw, OptionHandler h, ResourceBundle rb) {

		pw.print(' ');

		if (!h.option.required())

			pw.print('[');

		pw.print(h.getNameAndMeta(rb));

		if (h.option.isMultiValued()) {

			pw.print(" ...");

		}

		if (!h.option.required())

			pw.print(']');

	}

    private static final Logger LOGGER = Logger.getLogger(CmdLineParser.class.getName());

}

package org.kohsuke.args4j;

import org.kohsuke.args4j.spi.OptionHandler;

/**

 * Signals an error in the user input.

 *

 * @author Kohsuke Kawaguchi

 */

public class CmdLineException extends Exception {

	private static final long serialVersionUID = -8574071211991372980L;

    private CmdLineParser parser;

    /**

     * @deprecated

     *      Use {@link #CmdLineException(CmdLineParser, String)}

     */

    public CmdLineException(String message) {

        super(message);

    }

    /**

     * @deprecated

     *      Use {@link #CmdLineException(CmdLineParser, String, Throwable)}

     */

    public CmdLineException(String message, Throwable cause) {

        super(message, cause);

    }

    /**

     * @deprecated

     *      Use {@link #CmdLineException(CmdLineParser, Throwable)}

     */

    public CmdLineException(Throwable cause) {

        super(cause);

    }

    public CmdLineException(CmdLineParser parser, String message) {

        super(message);

        this.parser = parser;

    }

    public CmdLineException(CmdLineParser parser, String message, Throwable cause) {

        super(message, cause);

        this.parser = parser;

    }

    public CmdLineException(CmdLineParser parser, Throwable cause) {

        super(cause);

        this.parser = parser;

    }

    /**

     * Obtains the {@link CmdLineParser} that triggered an exception.

     *

     * <p>

     * Unless you have legacy {@link OptionHandler} that doesn't pass in this information

     * when it throws an exception, this method should always return a non-null value. a

     */

    public CmdLineParser getParser() {

        return parser;

    }

}

package org.kohsuke.args4j;

/**

 * Run-time copy of the Option or Argument annotation.

 */

public final class NamedOptionDef extends OptionDef {

    private final String name;

    private final String def;

    private final String widget;

	private final String[] aliases;

    public NamedOptionDef(Option o, boolean forceMultiValued) {

    	super(o.usage(),o.metaVar(),o.required(),o.handler(),o.multiValued() || forceMultiValued);

    	this.name = o.name();

    	this.def = o.def();

    	this.widget = o.widget();

    	this.aliases = o.aliases();

    }

    public String name() {

    	return name;

    }

    public String def() {

    	return def;

    }

    public String widget() {

    	return widget;

    }

    public String[] aliases() {

    	return aliases;

    }

    @Override

    public String toString() {

    	if (aliases.length > 0) {

    		String str = ""; //$NON-NLS-1$

    		for (String alias : aliases) {

    			if (str.length() > 0) {

    				str += ", "; //$NON-NLS-1$

    			}

    			str += alias;

    		}

    		return name() + " widget="+widget()+" (" + str + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

    	}

    	return name();

    }

    @Override

    public boolean isArgument() {

    	return false;

    }

}

MISSING_OPERAND = \u041E\u043F\u0446\u0438\u044F "{0}" \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043E\u043F\u0435\u0440\u0430\u043D\u0434

UNDEFINED_OPTION = "{0}" \u043D\u0435\u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0442\u0435\u043B\u044C\u043D\u0430\u044F \u043E\u043F\u0446\u0438\u044F

NO_ARGUMENT_ALLOWED = \u041D\u0435\u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0442\u0435\u043B\u044C\u043D\u044B\u0439 \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442\: {0}

REQUIRED_OPTION_MISSING = \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u043E\u043F\u0446\u0438\u044F "{0}"

REQUIRED_ARGUMENT_MISSING = \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442 "{0}"

TOO_MANY_ARGUMENTS = \u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u043D\u043E\u0433\u043E \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442\u043E\u0432\: {0}

# For translation

#------------------

# METADATA_ERROR =     Problems while reading the args-confguration.

# MULTIPLE_USE_OF_ARGUMENT =     Argument with index {0} is used more than once

# MULTIPLE_USE_OF_OPTION =     Option name {0} is used more than once

# UNKNOWN_HANDLER =     No OptionHandler is registered to handle {0}

# NO_OPTIONHANDLER =     Not an OptionHandler class

# NO_CONSTRUCTOR_ON_HANDLER =     {0} does not have the proper constructor

# FORMAT_ERROR_FOR_MAP =     An argument for setting a Map must contain a ''=''

# MAP_HAS_NO_KEY =     A key must be set.

package org.kohsuke.args4j;

/**

 * Used with {@link CmdLineParser#printExample(ExampleMode)}.

 *

 * @author Kohsuke Kawaguchi

 */

public enum ExampleMode {

    /**

     * Print all defined options in the example.

     *

     * <p>

     * This would be useful only when you have small number of options.

     */

    ALL() {

    	@Override

        /*package*/ boolean print(OptionDef o) {

            return true;

        }

    },