run() method.
34 | */
35 | public void xrun() {
36 | System.out.println("SampleStarter.run()");
37 | System.out.println(this);
38 | }
39 |
40 | /**
41 | * If you want to get the args-Array from the command line
42 | * use the signature run(String[] args). But then there must
43 | * not be a run() because that is executed prior to this.
44 | * @param args The arguments as specified on the command line
45 | */
46 | public void run(String[] args) {
47 | System.out.println("SampleStarter.run(String[])");
48 | System.out.println("- args.length: " + args.length);
49 | for (String arg : args) System.out.println(" - " + arg);
50 | System.out.println(this);
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/args4j/pom.xml:
--------------------------------------------------------------------------------
1 | 55 | * If you define multiple single value properties to bind to arguments, 56 | * they should have {@code index=0, index=1, index=2}, ... and so on. 57 | * 58 | *
59 | * Multi value properties bound to arguments must be always the last entry. 60 | */ 61 | int index() default 0; 62 | 63 | /** 64 | * 65 | */ 66 | boolean multiValued() default false; 67 | } 68 | -------------------------------------------------------------------------------- /args4j/src/org/kohsuke/args4j/ClassParser.java: -------------------------------------------------------------------------------- 1 | package org.kohsuke.args4j; 2 | 3 | import org.kohsuke.args4j.spi.MethodSetter; 4 | import org.kohsuke.args4j.spi.Setters; 5 | 6 | import java.lang.reflect.Field; 7 | import java.lang.reflect.Method; 8 | 9 | /** 10 | * Parser for analyzing Args4J annotations in the class hierarchy. 11 | * 12 | * This can be used to feed option bindings that span across multiple instances. 13 | * 14 | * @author Jan Materne 15 | */ 16 | public class ClassParser { 17 | public void parse(Object bean, CmdLineParser parser) { 18 | // recursively process all the methods/fields. 19 | for( Class c=bean.getClass(); c!=null; c=c.getSuperclass()) { 20 | for( Method m : c.getDeclaredMethods() ) { 21 | Option o = m.getAnnotation(Option.class); 22 | if(o!=null) { 23 | parser.addOption(new MethodSetter(parser,bean,m), o); 24 | } 25 | Argument a = m.getAnnotation(Argument.class); 26 | if(a!=null) { 27 | parser.addArgument(new MethodSetter(parser,bean,m), a); 28 | } 29 | } 30 | 31 | for( Field f : c.getDeclaredFields() ) { 32 | Option o = f.getAnnotation(Option.class); 33 | if(o!=null) { 34 | parser.addOption(Setters.create(f,bean),o); 35 | } 36 | Argument a = f.getAnnotation(Argument.class); 37 | if(a!=null) { 38 | parser.addArgument(Setters.create(f,bean), a); 39 | } 40 | } 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /args4j/src/org/kohsuke/args4j/CmdLineException.java: -------------------------------------------------------------------------------- 1 | package org.kohsuke.args4j; 2 | 3 | import java.util.Locale; 4 | import org.kohsuke.args4j.spi.OptionHandler; 5 | 6 | /** 7 | * Signals an error in the user input. 8 | * 9 | * @author Kohsuke Kawaguchi 10 | */ 11 | public class CmdLineException extends Exception { 12 | private static final long serialVersionUID = -8574071211991372980L; 13 | 14 | private CmdLineParser parser = null; 15 | 16 | /** 17 | * The optional localized message. 18 | * @see Throwable#getLocalizedMessage() 19 | */ 20 | private String localizedMessage = null; 21 | 22 | /** 23 | * @deprecated 24 | * Use {@link #CmdLineException(CmdLineParser, String)} 25 | */ 26 | public CmdLineException(String message) { 27 | super(message); 28 | } 29 | 30 | /** 31 | * @deprecated 32 | * Use {@link #CmdLineException(CmdLineParser, String, Throwable)} 33 | */ 34 | public CmdLineException(String message, Throwable cause) { 35 | super(message, cause); 36 | } 37 | 38 | /** 39 | * @deprecated 40 | * Use {@link #CmdLineException(CmdLineParser, Throwable)} 41 | */ 42 | public CmdLineException(Throwable cause) { 43 | super(cause); 44 | } 45 | 46 | public CmdLineException(CmdLineParser parser, Localizable message, String... args) { 47 | super(message.formatWithLocale(Locale.ENGLISH, (Object[])args)); 48 | this.localizedMessage = message.format((Object[])args); 49 | this.parser = parser; 50 | } 51 | 52 | /** 53 | * @deprecated 54 | * Use {@link #CmdLineException(org.kohsuke.args4j.CmdLineParser, Localizable, java.lang.String...) } 55 | */ 56 | public CmdLineException(CmdLineParser parser, String message) { 57 | super(message); 58 | this.parser = parser; 59 | } 60 | 61 | public CmdLineException(CmdLineParser parser, String message, Throwable cause) { 62 | super(message, cause); 63 | this.parser = parser; 64 | } 65 | 66 | public CmdLineException(CmdLineParser parser, Throwable cause) { 67 | super(cause); 68 | this.parser = parser; 69 | } 70 | 71 | @Override 72 | public String getLocalizedMessage() { 73 | if (localizedMessage != null) { 74 | return localizedMessage; 75 | } else { 76 | return getMessage(); 77 | } 78 | } 79 | 80 | /** 81 | * Obtains the {@link CmdLineParser} that triggered an exception. 82 | * 83 | *
84 | * Unless you have legacy {@link OptionHandler} that doesn't pass in this information
85 | * when it throws an exception, this method should always return a non-null value.
86 | */
87 | public CmdLineParser getParser() {
88 | return parser;
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Config.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.io.IOException;
4 | import java.util.ArrayList;
5 | import java.util.List;
6 |
7 | import org.kohsuke.args4j.spi.ConfigElement;
8 | import org.xml.sax.Attributes;
9 | import org.xml.sax.InputSource;
10 | import org.xml.sax.SAXException;
11 | import org.xml.sax.XMLReader;
12 | import org.xml.sax.helpers.DefaultHandler;
13 | import org.xml.sax.helpers.XMLReaderFactory;
14 |
15 |
16 | /**
17 | * Metadataconfiguration.
18 | * This class holds all metadata for a class, mainly a list of @Options and @Arguments.
19 | *
20 | * @author Jan Materne
21 | */
22 | public class Config {
23 |
24 | /** All @Options. */
25 | public List
17 | * This would only be useful with small numbers of options.
18 | */
19 | ALL() {
20 | public boolean select(OptionHandler o) {
21 | return true;
22 | }
23 | },
24 |
25 | /**
26 | * Print all {@linkplain Option#required() required} option.
27 | */
28 | REQUIRED() {
29 | public boolean select(OptionHandler o) {
30 | return o.option.required();
31 | }
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/FieldParser.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.lang.reflect.Field;
4 |
5 | import org.kohsuke.args4j.spi.ConfigElement;
6 | import org.kohsuke.args4j.spi.OptionImpl;
7 | import org.kohsuke.args4j.spi.Setters;
8 |
9 | /**
10 | * This metadata parser makes all field available to the CmdLineParser.
11 | * @author Jan Materne
12 | *
13 | */
14 | public class FieldParser {
15 |
16 | public void parse(CmdLineParser parser, Object bean) throws ClassNotFoundException {
17 | for(Class c=bean.getClass(); c!=null; c=c.getSuperclass()) {
18 | System.out.println("Class: " + c);
19 | for( Field f : c.getDeclaredFields() ) {
20 | Option o = new OptionImpl(createConfigElement(f));
21 | parser.addOption(Setters.create(f, bean), o );
22 | }
23 | }
24 | }
25 |
26 | private ConfigElement createConfigElement(Field f) {
27 | ConfigElement rv = new ConfigElement();
28 | rv.field = f.getName();
29 | rv.name = "-" + f.getName();
30 | return rv;
31 | }
32 |
33 | }
34 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/IllegalAnnotationError.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | /**
4 | * Signals an incorrect use of args4j annotations.
5 | *
6 | *
7 | * This only happens when there's something wrong with the way you use
8 | * args4j in your code--not when the user's arguments are wrong.
9 | * Therefore, this class is an {@link Error}.
10 | *
11 | * @author Kohsuke Kawaguchi
12 | */
13 | public class IllegalAnnotationError extends Error {
14 | private static final long serialVersionUID = 2397757838147693218L;
15 |
16 | public IllegalAnnotationError(String message) {
17 | super(message);
18 | }
19 |
20 | public IllegalAnnotationError(String message, Throwable cause) {
21 | super(message, cause);
22 | }
23 |
24 | public IllegalAnnotationError(Throwable cause) {
25 | super(cause);
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Localizable.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.text.MessageFormat;
4 | import java.util.Locale;
5 |
6 | /**
7 | * A message that can be formatted with arguments and locale.
8 | *
9 | * The message is implicitly given by {@code this} object and can
10 | * contain formatting similar to the {@link MessageFormat} class.
11 | *
12 | * @see Messages
13 | * @see org.kohsuke.args4j.spi.Messages
14 | * @author Stephan Fuhrmann
15 | */
16 | public interface Localizable {
17 |
18 | /**
19 | * Format the implicitly given message by {@code this} object with the given locale.
20 | * @param locale the locale to use for formatting .
21 | * @param args the arguments to use for formatting. See {@link MessageFormat#format(java.lang.String, java.lang.Object...)}.
22 | * @return the formatted string.
23 | */
24 | public String formatWithLocale( Locale locale, Object... args );
25 |
26 | /**
27 | * Format the implicitly given message by {@code this} object with the default locale.
28 | * @param args the arguments to use for formatting. See {@link MessageFormat#format(java.lang.String, java.lang.Object...)}.
29 | * @return the formatted string.
30 | */
31 | public String format( Object... args );
32 | }
33 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Messages.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.text.MessageFormat;
4 | import java.util.Locale;
5 | import java.util.ResourceBundle;
6 |
7 | /**
8 | * @author Kohsuke Kawaguchi
9 | */
10 | enum Messages implements Localizable {
11 | MISSING_OPERAND,
12 | UNDEFINED_OPTION,
13 | NO_ARGUMENT_ALLOWED,
14 | REQUIRED_OPTION_MISSING,
15 | TOO_MANY_ARGUMENTS,
16 | REQUIRED_ARGUMENT_MISSING,
17 | METADATA_ERROR,
18 | MULTIPLE_USE_OF_ARGUMENT,
19 | MULTIPLE_USE_OF_OPTION,
20 | UNKNOWN_HANDLER,
21 | NO_OPTIONHANDLER,
22 | NO_CONSTRUCTOR_ON_HANDLER,
23 | REQUIRES_OPTION_MISSING,
24 | FORBIDDEN_OPTION_PRESENT,
25 | NO_SUCH_FILE,
26 | DEFAULT_VALUE
27 | ;
28 |
29 | public String formatWithLocale( Locale locale, Object... args ) {
30 | ResourceBundle localized = ResourceBundle.getBundle(Messages.class.getName(), locale);
31 | return MessageFormat.format(localized.getString(name()),args);
32 | }
33 |
34 | public String format( Object... args ) {
35 | return formatWithLocale(Locale.getDefault(),args);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Messages.properties:
--------------------------------------------------------------------------------
1 | MISSING_OPERAND = \
2 | Option "{0}" takes an operand
3 |
4 | UNDEFINED_OPTION = \
5 | "{0}" is not a valid option
6 |
7 | NO_ARGUMENT_ALLOWED = \
8 | No argument is allowed: {0}
9 |
10 | REQUIRED_OPTION_MISSING = \
11 | Option "{0}" is required
12 |
13 | REQUIRED_ARGUMENT_MISSING = \
14 | Argument "{0}" is required
15 |
16 | TOO_MANY_ARGUMENTS = \
17 | Too many arguments: {0}
18 |
19 | METADATA_ERROR = \
20 | Problems while reading the args-confguration.
21 |
22 | MULTIPLE_USE_OF_ARGUMENT = \
23 | Argument with index {0} is used more than once
24 |
25 | MULTIPLE_USE_OF_OPTION = \
26 | Option name {0} is used more than once
27 |
28 | UNKNOWN_HANDLER = \
29 | No OptionHandler is registered to handle {0}
30 |
31 | NO_OPTIONHANDLER = \
32 | Not an OptionHandler class
33 |
34 | NO_CONSTRUCTOR_ON_HANDLER = \
35 | {0} does not have the proper constructor
36 |
37 | REQUIRES_OPTION_MISSING = \
38 | option "{0}" requires the option(s) {1}
39 |
40 | FORBIDDEN_OPTION_PRESENT = \
41 | option "{0}" cannot be used with the option(s) {1}
42 |
43 | NO_SUCH_FILE = \
44 | No such file: {0}
45 |
46 | DEFAULT_VALUE = \
47 | (default: {0})
48 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Messages_de.properties:
--------------------------------------------------------------------------------
1 | # Unicode for Umlauts
2 | # Ae, ae \u00c4, \u00e4
3 | # Oe, oe \u00d6, \u00f6
4 | # Ue, ue \u00dc, \u00fc
5 | # ss \u00df
6 |
7 |
8 |
9 | MISSING_OPERAND = \
10 | Option "{0}" ben\u00f6tigt einen Operanden
11 |
12 | UNDEFINED_OPTION = \
13 | "{0}" ist keine g\u00fcltige Option
14 |
15 | NO_ARGUMENT_ALLOWED = \
16 | Kein Argument erlaubt: {0}
17 |
18 | REQUIRED_OPTION_MISSING = \
19 | Option "{0}" wird ben\u00f6tigt
20 |
21 | REQUIRED_ARGUMENT_MISSING = \
22 | Argument "{0}" wird ben\u00f6tigt
23 |
24 | TOO_MANY_ARGUMENTS = \
25 | Zu viele Argumente: {0}
26 |
27 | METADATA_ERROR = \
28 | Kann die Args4J-Metadaten nicht lesen
29 |
30 | MULTIPLE_USE_OF_ARGUMENT = \
31 | Das Argument mit Index {0} ist mehr als einmal verwendet
32 |
33 | MULTIPLE_USE_OF_OPTION = \
34 | Die Option ''{0}'' ist mehr als einmal verwendet
35 |
36 | UNKNOWN_HANDLER = \
37 | Es ist kein OptionHandler f\u00fcr ''{0}'' registriert
38 |
39 | NO_OPTIONHANDLER = \
40 | Ist keine OptionHandler Klasse
41 |
42 | NO_CONSTRUCTOR_ON_HANDLER = \
43 | {0} hat nicht den notwendigen Konstruktor
44 |
45 | REQUIRES_OPTION_MISSING = \
46 | Option "{0}" ben\u00f6tigt die Option(en) {1}
47 |
48 | DEFAULT_VALUE = \
49 | (Vorgabe: {0})
50 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Messages_en.properties:
--------------------------------------------------------------------------------
1 | # this file is intentionally empty to fall back to the default
2 | # which is the English locale
3 |
4 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Messages_ru.properties:
--------------------------------------------------------------------------------
1 | MISSING_OPERAND = \u041E\u043F\u0446\u0438\u044F "{0}" \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043E\u043F\u0435\u0440\u0430\u043D\u0434
2 | UNDEFINED_OPTION = "{0}" \u043D\u0435\u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0442\u0435\u043B\u044C\u043D\u0430\u044F \u043E\u043F\u0446\u0438\u044F
3 | 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}
4 | REQUIRED_OPTION_MISSING = \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u043E\u043F\u0446\u0438\u044F "{0}"
5 | REQUIRED_ARGUMENT_MISSING = \u0422\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044F \u0430\u0440\u0433\u0443\u043C\u0435\u043D\u0442 "{0}"
6 | 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}
7 |
8 |
9 | # For translation
10 | #------------------
11 | # METADATA_ERROR = Problems while reading the args-confguration.
12 | # MULTIPLE_USE_OF_ARGUMENT = Argument with index {0} is used more than once
13 | # MULTIPLE_USE_OF_OPTION = Option name {0} is used more than once
14 | # UNKNOWN_HANDLER = No OptionHandler is registered to handle {0}
15 | # NO_OPTIONHANDLER = Not an OptionHandler class
16 | # NO_CONSTRUCTOR_ON_HANDLER = {0} does not have the proper constructor
17 | # FORMAT_ERROR_FOR_MAP = An argument for setting a Map must contain a '='
18 | # MAP_HAS_NO_KEY = A key must be set.
19 |
20 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/NamedOptionDef.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.util.Arrays;
4 |
5 | /**
6 | * Immutable run-time copy of {@link Option} annotation.
7 | */
8 | public final class NamedOptionDef extends OptionDef {
9 | private final String name;
10 | private final String[] aliases;
11 | private final String[] depends;
12 | private final String[] forbids;
13 |
14 | /**
15 | * @deprecated
16 | * multi-valuedness as option definition does not make sense. It's driven by the setter.
17 | */
18 | public NamedOptionDef(Option o, boolean forceMultiValued) {
19 | this(o);
20 | }
21 |
22 | public NamedOptionDef(Option o) {
23 | super(o.usage(),o.metaVar(),o.required(),o.help(),o.hidden(),o.handler(),false);
24 |
25 | this.name = o.name();
26 | this.aliases = createZeroSizedArrayIfNull(o.aliases());
27 | this.depends = createZeroSizedArrayIfNull(o.depends());
28 | this.forbids = createZeroSizedArrayIfNull(o.forbids());
29 | }
30 |
31 | private static String[] createZeroSizedArrayIfNull(String in[]) {
32 | if (in == null) {
33 | return new String[0];
34 | } else {
35 | return in;
36 | }
37 | }
38 |
39 | public String name() {
40 | return name;
41 | }
42 |
43 | public String[] aliases() {
44 | return Arrays.copyOf(aliases, aliases.length);
45 | }
46 |
47 | public String[] depends() {
48 | return Arrays.copyOf(depends, depends.length);
49 | }
50 |
51 | public String[] forbids() {
52 | return Arrays.copyOf(forbids, forbids.length);
53 | }
54 |
55 | @Override
56 | public String toString() {
57 | if (aliases.length > 0) {
58 | String str = "";
59 | for (String alias : aliases) {
60 | if (str.length() > 0) {
61 | str += ", ";
62 | }
63 | str += alias;
64 | }
65 | return name() + " (" + str + ")";
66 | }
67 | return name();
68 | }
69 |
70 | @Override
71 | public boolean isArgument() {
72 | return false;
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/OptionDef.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import org.kohsuke.args4j.spi.OptionHandler;
4 |
5 | /**
6 | * Run-time copy of the Option or Argument annotation. By definition, unnamed options
7 | * are arguments (and instances of this class). Named options are actually a subclass.
8 | *
9 | * @author Mark Sinke
10 | */
11 | public class OptionDef {
12 | private final String usage;
13 | private final String metaVar;
14 | private final boolean required;
15 | private final boolean help;
16 | private final boolean hidden;
17 | private final boolean multiValued;
18 | private final Class handler;
19 |
20 | public OptionDef(Argument a, boolean forceMultiValued) {
21 | this(a.usage(), a.metaVar(), a.required(), false, a.hidden(), a.handler(), a.multiValued() || forceMultiValued);
22 | }
23 |
24 | protected OptionDef(String usage, String metaVar, boolean required,
25 | boolean help, boolean hidden,
26 | Class handler,
27 | boolean multiValued) {
28 | this.usage = usage;
29 | this.metaVar = metaVar;
30 | this.required = required;
31 | this.help = help;
32 | this.hidden = hidden;
33 | this.handler = handler;
34 | this.multiValued = multiValued;
35 | }
36 |
37 | public String usage() {
38 | return usage;
39 | }
40 |
41 | public String metaVar() {
42 | return metaVar;
43 | }
44 |
45 | public boolean required() {
46 | return required;
47 | }
48 |
49 | public boolean help() {
50 | return help;
51 | }
52 |
53 | /**
54 | * Value from {@link Option#hidden()} or {@link Argument#hidden()}
55 | */
56 | public boolean hidden() {
57 | return hidden;
58 | }
59 |
60 | public Class handler() {
61 | return handler;
62 | }
63 |
64 | public boolean isMultiValued() {
65 | return multiValued;
66 | }
67 |
68 | public boolean isArgument() {
69 | return true;
70 | }
71 |
72 | @Override
73 | public String toString() {
74 | return metaVar() != null ? metaVar() : "ARG";
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/OptionHandlerFilter.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import org.kohsuke.args4j.spi.OptionHandler;
4 |
5 | import java.io.Writer;
6 | import java.util.ResourceBundle;
7 |
8 | /**
9 | * Selects {@link OptionHandler}.
10 | *
11 | *
12 | * For example, we use this to let the caller specify which
13 | * options are printed, and which ones aren't.
14 | *
15 | * @author Kohsuke Kawaguchi
16 | * @see CmdLineParser#printExample(OptionHandlerFilter)
17 | * @see CmdLineParser#printUsage(Writer, ResourceBundle, OptionHandlerFilter)
18 | */
19 | public interface OptionHandlerFilter {
20 | /**
21 | *
22 | * @param o
23 | * Never {@code null}. Internally options (like
44 | * This would only be useful with a small number of options.
45 | */
46 | OptionHandlerFilter PUBLIC = new OptionHandlerFilter() {
47 | public boolean select(OptionHandler o) {
48 | return !o.option.hidden();
49 | }
50 | };
51 |
52 | /**
53 | * Print all {@linkplain Option#required() required} options.
54 | */
55 | OptionHandlerFilter REQUIRED = new OptionHandlerFilter() {
56 | public boolean select(OptionHandler o) {
57 | return o.option.required();
58 | }
59 | };
60 | }
61 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Starter.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.lang.annotation.Annotation;
4 | import java.lang.reflect.Field;
5 | import java.lang.reflect.InvocationTargetException;
6 | import java.lang.reflect.Method;
7 |
8 | /**
9 | * Starter class which uses reflection to instantiate the business
10 | * class, parse the command line parameters, sets the fields of the
11 | * business class and doing the help message handling.
12 | *
13 | * @author Jan Materne
14 | */
15 | public class Starter {
16 |
17 | /**
18 | * The name of the JavaVM property which stores the class name of
19 | * the business class.
20 | * {@value}
21 | */
22 | public static final String PARAMETER_NAME = "mainclass";
23 |
24 | public static void main(String[] args) {
25 | String classname = System.getProperty(PARAMETER_NAME);
26 | CmdLineParser parser = null;
27 | boolean classHasArgument = false;
28 | boolean classHasOptions = false;
29 |
30 | // Check the requirement: must specify the class to start
31 | if (classname == null || "".equals(classname)) {
32 | System.err.println("The system property '"
33 | + PARAMETER_NAME
34 | + "' must contain the classname to start.");
35 | System.exit(-1);
36 | }
37 |
38 | try {
39 | Class clazz = Class.forName(classname);
40 | Object bean = clazz.newInstance();
41 | parser = new CmdLineParser(bean);
42 |
43 | // for help output
44 | classHasArgument = hasAnnotation(clazz, Argument.class);
45 | classHasOptions = hasAnnotation(clazz, Option.class);
46 |
47 | parser.parseArgument(args);
48 |
49 | // try starting run()
50 | Method m;
51 | boolean couldInvoke = false;
52 | try {
53 | m = clazz.getMethod("run", (Class[]) null);
54 | m.invoke(bean, (Object[]) null);
55 | couldInvoke = true;
56 | } catch (SecurityException e) {
57 | } catch (IllegalArgumentException e) {
58 | } catch (NoSuchMethodException e) {
59 | } catch (IllegalAccessException e) {
60 | } catch (InvocationTargetException e) {
61 | }
62 |
63 | // try starting run(String[])
64 | if (!couldInvoke) try {
65 | m = clazz.getMethod("run", String[].class);
66 | m.invoke(bean, new Object[]{args});
67 | couldInvoke = true;
68 | } catch (SecurityException e) {
69 | } catch (IllegalArgumentException e) {
70 | e.printStackTrace();
71 | } catch (NoSuchMethodException e) {
72 | } catch (IllegalAccessException e) {
73 | } catch (InvocationTargetException e) {
74 | }
75 | } catch (ClassNotFoundException e) {
76 | // wrong classpath setting
77 | System.err.println("Cant find the class '"
78 | + classname
79 | + "' as specified in the system property '"
80 | + PARAMETER_NAME + "'.");
81 | } catch (CmdLineException e) {
82 | // wrong argument enteres, so print the usage message as
83 | // supplied by args4j
84 | System.err.println(e.getMessage());
85 | System.err.print(classname);
86 | if (classHasOptions) System.err.print(" [options]");
87 | if (classHasArgument) System.err.print(" arguments");
88 | System.err.println();
89 | if (parser != null)
90 | parser.printUsage(System.err);
91 | } catch (Exception e) {
92 | // Must be an unhandled business exception, so we can only
93 | // print stacktraces.
94 | e.printStackTrace();
95 | }
96 | }
97 |
98 | public static boolean hasAnnotation(Class clazz, Class annotation) {
99 | if (clazz.getAnnotation(annotation)!=null) return true;
100 | for (Field f : clazz.getFields()) {
101 | if (f.getAnnotation(annotation)!=null) return true;
102 | }
103 | for (Method m : clazz.getMethods()) {
104 | if (m.getAnnotation(annotation)!=null) return true;
105 | }
106 | return false;
107 | }
108 |
109 | }
110 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/Utilities.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | /**
4 | * Misc utility methods. Don't make this
5 | * class visible to the outside world.
6 | * When we switch to JDK 1.7, re-check the sense
7 | * of this class.
8 | */
9 | class Utilities {
10 |
11 | private Utilities() {
12 | // no instance
13 | }
14 |
15 | /** This method is similar to {@code Objects.requireNonNull()}.
16 | * But this one is available for JDK 1.6 which is the
17 | * current target of args4j.
18 | * I didn't want to break compatibility with JDK 1.6.
19 | * @param obj the object to check for {@code null} value.
20 | * @param name the object name. If {@code obj} is {@code null}, then
21 | * an exception is constructed from this name.
22 | */
23 | static void checkNonNull(Object obj, String name) {
24 | if (obj == null) {
25 | throw new NullPointerException(name+" is null");
26 | }
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/args4j/src/org/kohsuke/args4j/XmlParser.java:
--------------------------------------------------------------------------------
1 | package org.kohsuke.args4j;
2 |
3 | import java.lang.reflect.AccessibleObject;
4 | import java.net.URL;
5 |
6 | import org.kohsuke.args4j.spi.ArgumentImpl;
7 | import org.kohsuke.args4j.spi.ConfigElement;
8 | import org.kohsuke.args4j.spi.OptionImpl;
9 | import org.kohsuke.args4j.spi.Setters;
10 | import org.xml.sax.InputSource;
11 |
12 | /**
13 | * Parses an XML-file specifying the 'annotations'.
14 | * The XML must have the structure:
15 | * Core classes of the Args4J command line parser.
9 | Args4J is a command line parser.
10 | As such, its job is to parse the String-array passed to the Args4J must know the mapping between the flag from the command line and the target for the value.
17 | There are many ways to use Args4J: Depending on what you want, you may have perform a configuration step before parsing. The typical use involves writing a small bean class and providing the annotations. This feature is available since the first Args4J release: An easy way to initialize fields without touching the bean source code is to use the The This feature is available since Args4J release 2.0.16: While the That said, it supports all features which are available via annotations: usage text, specifying handlers, and more. You have to provide an XML This feature is available since Args4J release 2.0.16:-r) and arguments (others)
24 | * are treated uniformly as {@link OptionHandler}.
25 | * See {@link OptionDef#isArgument()} to distinguish them.
26 | * @return
27 | * true to choose this option, false to ignore/discard/disregard it.
28 | */
29 | boolean select(OptionHandler o);
30 |
31 | /**
32 | * Print all defined options in the example.
33 | */
34 | OptionHandlerFilter ALL = new OptionHandlerFilter() {
35 | public boolean select(OptionHandler o) {
36 | return true;
37 | }
38 | };
39 |
40 | /**
41 | * Print all {@linkplain Option#hidden() non-hidden} options.
42 | *
43 | *
16 | * <args>
17 | * <option field="" method="" name="" usage="" metavar="" handler=""/>
18 | * <argument field="" method="" usage="" metavar="" handler=""/>
19 | * </args>
20 | *
21 | * Exactly one of the attributes 'field' or 'method' must be set.
22 | * The 'handler' value specifies a full qualified class name.
23 | *
24 | * Example
25 | *
26 | * <args>
27 | * <option field="recursive" name="-r" usage="recursively run something"/>
28 | * <option field="out" name="-o" usage="output to this file" metavar="OUTPUT"/>
29 | * <option method="setStr(String)" name="-str"/>
30 | * <option field="data" name="-custom" handler="org.kohsuke.args4j.spi.BooleanOptionHandler" usage="boolean value for checking the custom handler"/>
31 | * <argument field="arguments"/>
32 | * <args>
33 | *
34 | *
35 | * @author Jan Materne
36 | */
37 | public class XmlParser {
38 | public void parse(URL xml, CmdLineParser parser, Object bean) {
39 | parse(new InputSource(xml.toExternalForm()),parser,bean);
40 | }
41 |
42 | public void parse(InputSource xml, CmdLineParser parser, Object bean) {
43 | try {
44 | Config config = Config.parse(xml);
45 | for(ConfigElement ce : config.options) {
46 | Option option = new OptionImpl(ce);
47 | parser.addOption(Setters.create(parser, findMethodOrField(bean, ce.field, ce.method),bean), option);
48 | }
49 | for (ConfigElement ce : config.arguments) {
50 | Argument argument = new ArgumentImpl(ce);
51 | parser.addArgument(Setters.create(parser, findMethodOrField(bean, ce.field, ce.method),bean), argument);
52 | }
53 | } catch (Exception e) {
54 | throw new RuntimeException(Messages.METADATA_ERROR.format(), e);
55 | }
56 | }
57 |
58 |
59 | /**
60 | * Finds a {@link java.lang.reflect.Method} or {@link java.lang.reflect.Method} in the bean
61 | * instance with the requested name.
62 | * @param bean bean instance
63 | * @param field name of the field (field XOR method must be specified)
64 | * @param method name of the method (field XOR method must be specified)
65 | * @return the reflection reference
66 | * @throws SecurityException
67 | * @throws NoSuchFieldException
68 | * @throws NoSuchMethodException
69 | * @throws ClassNotFoundException
70 | */
71 | private AccessibleObject findMethodOrField(Object bean, String field, String method) throws SecurityException, NoSuchFieldException, NoSuchMethodException, ClassNotFoundException {
72 | AccessibleObject rv;
73 | if (field != null) {
74 | rv = bean.getClass().getDeclaredField(field);
75 | } else {
76 | String methodName = method.substring(0, method.indexOf("("));
77 | String[] params = method.substring(method.indexOf("(")+1, method.indexOf(")")).split(",");
78 | Class[] paramTypes = new Class[params.length];
79 | for(int i=0; iWhat is Args4J?
7 |
8 | main() method and
11 | transfer the values to a Java object, which includes type conversion.
12 | The entry point into this parsing is the CmdLineParser class,
13 | with its parse() method.
14 |
20 |
24 |
25 | @Option or @Argument annotation at a setter or on a fieldExamples
29 |
30 | java Main -text newText
36 | public class Bean {
37 | {@literal @}Option(name="-text")
38 | String text;
39 | }
40 | public class Main {
41 | public static void main(String[] args) throws CmdLineException {
42 | Object bean = new Bean();
43 | CmdLineParser parser = new CmdLineParser(bean);
44 | parser.parse(args);
45 | }
46 | }
47 |
48 |
49 |
50 | FieldParser.FieldParser scans all fields of bean class (including inheritance), and makes them publicly available as options with a - prefix in the name.
57 | public class Bean {
58 | String text;
59 | }
60 | public class Main {
61 | public static void main(String[] args) throws CmdLineException {
62 | Object bean = new Bean();
63 | CmdLineParser parser = new CmdLineParser(null);
64 | new FieldParser().parse(parser, bean);
65 | parser.parse(args);
66 | }
67 | }
68 | FieldParser is easier to use, the XmlParser supports more features.InputSource or a URL to the XML file.
76 | public class Bean {
77 | String text;
78 | }
79 | public class Main {
80 | public static void main(String[] args) throws CmdLineException {
81 | Object bean = new Bean();
82 | CmdLineParser parser = new CmdLineParser(null);
83 | new XmlParser().parse(getClass().getResource(bean.getClass().getName() + ".xml"), parser, bean);
84 | parser.parse(args);
85 | }
86 | }
87 | <args>
88 | <option field="text" name="-text" usage="Output text"/>
89 | </args>
90 |