| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.sdklib.util; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.utils.ILogger; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map.Entry; |
| |
| /** |
| * Parses the command-line and stores flags needed or requested. |
| * <p/> |
| * This is a base class. To be useful you want to: |
| * <ul> |
| * <li>override it. |
| * <li>pass an action array to the constructor. |
| * <li>define flags for your actions. |
| * </ul> |
| * <p/> |
| * To use, call {@link #parseArgs(String[])} and then |
| * call {@link #getValue(String, String, String)}. |
| */ |
| public class CommandLineParser { |
| |
| /* |
| * Steps needed to add a new action: |
| * - Each action is defined as a "verb object" followed by parameters. |
| * - Either reuse a VERB_ constant or define a new one. |
| * - Either reuse an OBJECT_ constant or define a new one. |
| * - Add a new entry to mAction with a one-line help summary. |
| * - In the constructor, add a define() call for each parameter (either mandatory |
| * or optional) for the given action. |
| */ |
| |
| /** Internal verb name for internally hidden flags. */ |
| public static final String GLOBAL_FLAG_VERB = "@@internal@@"; //$NON-NLS-1$ |
| |
| /** String to use when the verb doesn't need any object. */ |
| public static final String NO_VERB_OBJECT = ""; //$NON-NLS-1$ |
| |
| /** The global help flag. */ |
| public static final String KEY_HELP = "help"; |
| /** The global verbose flag. */ |
| public static final String KEY_VERBOSE = "verbose"; |
| /** The global silent flag. */ |
| public static final String KEY_SILENT = "silent"; |
| |
| /** Verb requested by the user. Null if none specified, which will be an error. */ |
| private String mVerbRequested; |
| /** Direct object requested by the user. Can be null. */ |
| private String mDirectObjectRequested; |
| |
| /** |
| * Action definitions. |
| * <p/> |
| * This list serves two purposes: first it is used to know which verb/object |
| * actions are acceptable on the command-line; second it provides a summary |
| * for each action that is printed in the help. |
| * <p/> |
| * Each entry is a string array with: |
| * <ul> |
| * <li> the verb. |
| * <li> a direct object (use {@link #NO_VERB_OBJECT} if there's no object). |
| * <li> a description. |
| * <li> an alternate form for the object (e.g. plural). |
| * </ul> |
| */ |
| private final String[][] mActions; |
| |
| private static final int ACTION_VERB_INDEX = 0; |
| private static final int ACTION_OBJECT_INDEX = 1; |
| private static final int ACTION_DESC_INDEX = 2; |
| private static final int ACTION_ALT_OBJECT_INDEX = 3; |
| |
| /** |
| * The map of all defined arguments. |
| * <p/> |
| * The key is a string "verb/directObject/longName". |
| */ |
| private final HashMap<String, Arg> mArguments = new HashMap<String, Arg>(); |
| /** Logger */ |
| private final ILogger mLog; |
| |
| /** |
| * Constructs a new command-line processor. |
| * |
| * @param logger An SDK logger object. Must not be null. |
| * @param actions The list of actions recognized on the command-line. |
| * See the javadoc of {@link #mActions} for more details. |
| * |
| * @see #mActions |
| */ |
| public CommandLineParser(ILogger logger, String[][] actions) { |
| mLog = logger; |
| mActions = actions; |
| |
| /* |
| * usage should fit in 80 columns, including the space to print the options: |
| * " -v --verbose 7890123456789012345678901234567890123456789012345678901234567890" |
| */ |
| |
| define(Mode.BOOLEAN, false, GLOBAL_FLAG_VERB, NO_VERB_OBJECT, "v", KEY_VERBOSE, |
| "Verbose mode, shows errors, warnings and all messages.", |
| false); |
| define(Mode.BOOLEAN, false, GLOBAL_FLAG_VERB, NO_VERB_OBJECT, "s", KEY_SILENT, |
| "Silent mode, shows errors only.", |
| false); |
| define(Mode.BOOLEAN, false, GLOBAL_FLAG_VERB, NO_VERB_OBJECT, "h", KEY_HELP, |
| "Help on a specific command.", |
| false); |
| } |
| |
| /** |
| * Indicates if this command-line can work when no verb is specified. |
| * The default is false, which generates an error when no verb/object is specified. |
| * Derived implementations can set this to true if they can deal with a lack |
| * of verb/action. |
| */ |
| public boolean acceptLackOfVerb() { |
| return false; |
| } |
| |
| |
| //------------------ |
| // Helpers to get flags values |
| |
| /** Helper that returns true if --verbose was requested. */ |
| public boolean isVerbose() { |
| return ((Boolean) getValue(GLOBAL_FLAG_VERB, NO_VERB_OBJECT, KEY_VERBOSE)).booleanValue(); |
| } |
| |
| /** Helper that returns true if --silent was requested. */ |
| public boolean isSilent() { |
| return ((Boolean) getValue(GLOBAL_FLAG_VERB, NO_VERB_OBJECT, KEY_SILENT)).booleanValue(); |
| } |
| |
| /** Helper that returns true if --help was requested. */ |
| public boolean isHelpRequested() { |
| return ((Boolean) getValue(GLOBAL_FLAG_VERB, NO_VERB_OBJECT, KEY_HELP)).booleanValue(); |
| } |
| |
| /** Returns the verb name from the command-line. Can be null. */ |
| public String getVerb() { |
| return mVerbRequested; |
| } |
| |
| /** Returns the direct object name from the command-line. Can be null. */ |
| public String getDirectObject() { |
| return mDirectObjectRequested; |
| } |
| |
| //------------------ |
| |
| /** |
| * Raw access to parsed parameter values. |
| * <p/> |
| * The default is to scan all parameters. Parameters that have been explicitly set on the |
| * command line are returned first. Otherwise one with a non-null value is returned. |
| * <p/> |
| * Both a verb and a direct object filter can be specified. When they are non-null they limit |
| * the scope of the search. |
| * <p/> |
| * If nothing has been found, return the last default value seen matching the filter. |
| * |
| * @param verb The verb name, including {@link #GLOBAL_FLAG_VERB}. If null, all possible |
| * verbs that match the direct object condition will be examined and the first |
| * value set will be used. |
| * @param directObject The direct object name, including {@link #NO_VERB_OBJECT}. If null, |
| * all possible direct objects that match the verb condition will be examined and |
| * the first value set will be used. |
| * @param longFlagName The long flag name for the given action. Mandatory. Cannot be null. |
| * @return The current value object stored in the parameter, which depends on the argument mode. |
| */ |
| public Object getValue(String verb, String directObject, String longFlagName) { |
| |
| if (verb != null && directObject != null) { |
| String key = verb + '/' + directObject + '/' + longFlagName; |
| Arg arg = mArguments.get(key); |
| return arg.getCurrentValue(); |
| } |
| |
| Object lastDefault = null; |
| for (Arg arg : mArguments.values()) { |
| if (arg.getLongArg().equals(longFlagName)) { |
| if (verb == null || arg.getVerb().equals(verb)) { |
| if (directObject == null || arg.getDirectObject().equals(directObject)) { |
| if (arg.isInCommandLine()) { |
| return arg.getCurrentValue(); |
| } |
| if (arg.getCurrentValue() != null) { |
| lastDefault = arg.getCurrentValue(); |
| } |
| } |
| } |
| } |
| } |
| |
| return lastDefault; |
| } |
| |
| /** |
| * Internal setter for raw parameter value. |
| * @param verb The verb name, including {@link #GLOBAL_FLAG_VERB}. |
| * @param directObject The direct object name, including {@link #NO_VERB_OBJECT}. |
| * @param longFlagName The long flag name for the given action. |
| * @param value The new current value object stored in the parameter, which depends on the |
| * argument mode. |
| */ |
| protected void setValue(String verb, String directObject, String longFlagName, Object value) { |
| String key = verb + '/' + directObject + '/' + longFlagName; |
| Arg arg = mArguments.get(key); |
| arg.setCurrentValue(value); |
| } |
| |
| /** |
| * Parses the command-line arguments. |
| * <p/> |
| * This method will exit and not return if a parsing error arise. |
| * |
| * @param args The arguments typically received by a main method. |
| */ |
| public void parseArgs(String[] args) { |
| String errorMsg = null; |
| String verb = null; |
| String directObject = null; |
| |
| try { |
| int n = args.length; |
| for (int i = 0; i < n; i++) { |
| Arg arg = null; |
| String a = args[i]; |
| if (a.startsWith("--")) { //$NON-NLS-1$ |
| arg = findLongArg(verb, directObject, a.substring(2)); |
| } else if (a.startsWith("-")) { //$NON-NLS-1$ |
| arg = findShortArg(verb, directObject, a.substring(1)); |
| } |
| |
| // No matching argument name found |
| if (arg == null) { |
| // Does it looks like a dashed parameter? |
| if (a.startsWith("-")) { //$NON-NLS-1$ |
| if (verb == null || directObject == null) { |
| // It looks like a dashed parameter and we don't have a a verb/object |
| // set yet, the parameter was just given too early. |
| |
| errorMsg = String.format( |
| "Flag '%1$s' is not a valid global flag. Did you mean to specify it after the verb/object name?", |
| a); |
| return; |
| } else { |
| // It looks like a dashed parameter but it is unknown by this |
| // verb-object combination |
| |
| errorMsg = String.format( |
| "Flag '%1$s' is not valid for '%2$s %3$s'.", |
| a, verb, directObject); |
| return; |
| } |
| } |
| |
| if (verb == null) { |
| // Fill verb first. Find it. |
| for (String[] actionDesc : mActions) { |
| if (actionDesc[ACTION_VERB_INDEX].equals(a)) { |
| verb = a; |
| break; |
| } |
| } |
| |
| // Error if it was not a valid verb |
| if (verb == null) { |
| errorMsg = String.format( |
| "Expected verb after global parameters but found '%1$s' instead.", |
| a); |
| return; |
| } |
| |
| } else if (directObject == null) { |
| // Then fill the direct object. Find it. |
| for (String[] actionDesc : mActions) { |
| if (actionDesc[ACTION_VERB_INDEX].equals(verb)) { |
| if (actionDesc[ACTION_OBJECT_INDEX].equals(a)) { |
| directObject = a; |
| break; |
| } else if (actionDesc.length > ACTION_ALT_OBJECT_INDEX && |
| actionDesc[ACTION_ALT_OBJECT_INDEX].equals(a)) { |
| // if the alternate form exist and is used, we internally |
| // only memorize the default direct object form. |
| directObject = actionDesc[ACTION_OBJECT_INDEX]; |
| break; |
| } |
| } |
| } |
| |
| // Error if it was not a valid object for that verb |
| if (directObject == null) { |
| errorMsg = String.format( |
| "Expected verb after global parameters but found '%1$s' instead.", |
| a); |
| return; |
| |
| } |
| } else { |
| // The argument is not a dashed parameter and we already |
| // have a verb/object. Must be some extra unknown argument. |
| errorMsg = String.format( |
| "Argument '%1$s' is not recognized.", |
| a); |
| } |
| } else if (arg != null) { |
| // This argument was present on the command line |
| arg.setInCommandLine(true); |
| |
| // Process keyword |
| Object error = null; |
| if (arg.getMode().needsExtra()) { |
| if (i+1 >= n) { |
| errorMsg = String.format("Missing argument for flag %1$s.", a); |
| return; |
| } |
| |
| while (i+1 < n) { |
| String b = args[i+1]; |
| |
| if (arg.getMode() != Mode.STRING_ARRAY) { |
| // We never accept something that looks like a valid argument |
| // unless we see -- first |
| Arg dummyArg = null; |
| if (b.startsWith("--")) { //$NON-NLS-1$ |
| dummyArg = findLongArg(verb, directObject, b.substring(2)); |
| } else if (b.startsWith("-")) { //$NON-NLS-1$ |
| dummyArg = findShortArg(verb, directObject, b.substring(1)); |
| } |
| if (dummyArg != null) { |
| errorMsg = String.format( |
| "Oops, it looks like you didn't provide an argument for '%1$s'.\n'%2$s' was found instead.", |
| a, b); |
| return; |
| } |
| } |
| |
| error = arg.getMode().process(arg, b); |
| if (error == Accept.CONTINUE) { |
| i++; |
| } else if (error == Accept.ACCEPT_AND_STOP) { |
| i++; |
| break; |
| } else if (error == Accept.REJECT_AND_STOP) { |
| break; |
| } else if (error instanceof String) { |
| // We stop because of an error |
| break; |
| } |
| } |
| } else { |
| error = arg.getMode().process(arg, null); |
| |
| if (isHelpRequested()) { |
| // The --help flag was requested. We'll continue the usual processing |
| // so that we can find the optional verb/object words. Those will be |
| // used to print specific help. |
| // Setting a non-null error message triggers printing the help, however |
| // there is no specific error to print. |
| errorMsg = ""; //$NON-NLS-1$ |
| } |
| } |
| |
| if (error instanceof String) { |
| errorMsg = String.format("Invalid usage for flag %1$s: %2$s.", a, error); |
| return; |
| } |
| } |
| } |
| |
| if (errorMsg == null) { |
| if (verb == null && !acceptLackOfVerb()) { |
| errorMsg = "Missing verb name."; |
| } else if (verb != null) { |
| if (directObject == null) { |
| // Make sure this verb has an optional direct object |
| for (String[] actionDesc : mActions) { |
| if (actionDesc[ACTION_VERB_INDEX].equals(verb) && |
| actionDesc[ACTION_OBJECT_INDEX].equals(NO_VERB_OBJECT)) { |
| directObject = NO_VERB_OBJECT; |
| break; |
| } |
| } |
| |
| if (directObject == null) { |
| errorMsg = String.format("Missing object name for verb '%1$s'.", verb); |
| return; |
| } |
| } |
| |
| // Validate that all mandatory arguments are non-null for this action |
| String missing = null; |
| boolean plural = false; |
| for (Entry<String, Arg> entry : mArguments.entrySet()) { |
| Arg arg = entry.getValue(); |
| if (arg.getVerb().equals(verb) && |
| arg.getDirectObject().equals(directObject)) { |
| if (arg.isMandatory() && arg.getCurrentValue() == null) { |
| if (missing == null) { |
| missing = "--" + arg.getLongArg(); //$NON-NLS-1$ |
| } else { |
| missing += ", --" + arg.getLongArg(); //$NON-NLS-1$ |
| plural = true; |
| } |
| } |
| } |
| } |
| |
| if (missing != null) { |
| errorMsg = String.format( |
| "The %1$s %2$s must be defined for action '%3$s %4$s'", |
| plural ? "parameters" : "parameter", |
| missing, |
| verb, |
| directObject); |
| } |
| |
| mVerbRequested = verb; |
| mDirectObjectRequested = directObject; |
| } |
| } |
| } finally { |
| if (errorMsg != null) { |
| printHelpAndExitForAction(verb, directObject, errorMsg); |
| } |
| } |
| } |
| |
| /** |
| * Finds an {@link Arg} given an action name and a long flag name. |
| * @return The {@link Arg} found or null. |
| */ |
| protected Arg findLongArg(String verb, String directObject, String longName) { |
| if (verb == null) { |
| verb = GLOBAL_FLAG_VERB; |
| } |
| if (directObject == null) { |
| directObject = NO_VERB_OBJECT; |
| } |
| String key = verb + '/' + directObject + '/' + longName; //$NON-NLS-1$ |
| return mArguments.get(key); |
| } |
| |
| /** |
| * Finds an {@link Arg} given an action name and a short flag name. |
| * @return The {@link Arg} found or null. |
| */ |
| protected Arg findShortArg(String verb, String directObject, String shortName) { |
| if (verb == null) { |
| verb = GLOBAL_FLAG_VERB; |
| } |
| if (directObject == null) { |
| directObject = NO_VERB_OBJECT; |
| } |
| |
| for (Entry<String, Arg> entry : mArguments.entrySet()) { |
| Arg arg = entry.getValue(); |
| if (arg.getVerb().equals(verb) && arg.getDirectObject().equals(directObject)) { |
| if (shortName.equals(arg.getShortArg())) { |
| return arg; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Prints the help/usage and exits. |
| * |
| * @param errorFormat Optional error message to print prior to usage using String.format |
| * @param args Arguments for String.format |
| */ |
| public void printHelpAndExit(String errorFormat, Object... args) { |
| printHelpAndExitForAction(null /*verb*/, null /*directObject*/, errorFormat, args); |
| } |
| |
| /** |
| * Prints the help/usage and exits. |
| * |
| * @param verb If null, displays help for all verbs. If not null, display help only |
| * for that specific verb. In all cases also displays general usage and action list. |
| * @param directObject If null, displays help for all verb objects. |
| * If not null, displays help only for that specific action |
| * In all cases also display general usage and action list. |
| * @param errorFormat Optional error message to print prior to usage using String.format |
| * @param args Arguments for String.format |
| */ |
| public void printHelpAndExitForAction(String verb, String directObject, |
| String errorFormat, Object... args) { |
| if (errorFormat != null && !errorFormat.isEmpty()) { |
| stderr(errorFormat, args); |
| } |
| |
| /* |
| * usage should fit in 80 columns |
| * 12345678901234567890123456789012345678901234567890123456789012345678901234567890 |
| */ |
| stdout("\n" + |
| "Usage:\n" + |
| " android [global options] %s [action options]\n" + |
| "\n" + |
| "Global options:", |
| verb == null ? "action" : |
| verb + (directObject == null ? "" : " " + directObject)); //$NON-NLS-1$ |
| listOptions(GLOBAL_FLAG_VERB, NO_VERB_OBJECT); |
| |
| if (verb == null || directObject == null) { |
| stdout("\nValid actions are composed of a verb and an optional direct object:"); |
| for (String[] action : mActions) { |
| if (verb == null || verb.equals(action[ACTION_VERB_INDEX])) { |
| stdout("- %1$6s %2$-13s: %3$s", |
| action[ACTION_VERB_INDEX], |
| action[ACTION_OBJECT_INDEX], |
| action[ACTION_DESC_INDEX]); |
| } |
| } |
| } |
| |
| // Only print details if a verb/object is requested |
| if (verb != null) { |
| for (String[] action : mActions) { |
| if (verb == null || verb.equals(action[ACTION_VERB_INDEX])) { |
| if (directObject == null || directObject.equals(action[ACTION_OBJECT_INDEX])) { |
| stdout("\nAction \"%1$s %2$s\":", |
| action[ACTION_VERB_INDEX], |
| action[ACTION_OBJECT_INDEX]); |
| stdout(" %1$s", action[ACTION_DESC_INDEX]); |
| stdout("Options:"); |
| listOptions(action[ACTION_VERB_INDEX], action[ACTION_OBJECT_INDEX]); |
| } |
| } |
| } |
| } |
| |
| exit(); |
| } |
| |
| /** |
| * Internal helper to print all the option flags for a given action name. |
| */ |
| protected void listOptions(String verb, String directObject) { |
| int numOptions = 0; |
| int longArgLen = 8; |
| |
| for (Entry<String, Arg> entry : mArguments.entrySet()) { |
| Arg arg = entry.getValue(); |
| if (arg.getVerb().equals(verb) && arg.getDirectObject().equals(directObject)) { |
| int n = arg.getLongArg().length(); |
| if (n > longArgLen) { |
| longArgLen = n; |
| } |
| } |
| } |
| |
| for (Entry<String, Arg> entry : mArguments.entrySet()) { |
| Arg arg = entry.getValue(); |
| if (arg.getVerb().equals(verb) && arg.getDirectObject().equals(directObject)) { |
| |
| String value = ""; //$NON-NLS-1$ |
| String required = ""; //$NON-NLS-1$ |
| if (arg.isMandatory()) { |
| required = " [required]"; |
| |
| } else { |
| if (arg.getDefaultValue() instanceof String[]) { |
| for (String v : (String[]) arg.getDefaultValue()) { |
| if (!value.isEmpty()) { |
| value += ", "; |
| } |
| value += v; |
| } |
| } else if (arg.getDefaultValue() != null) { |
| Object v = arg.getDefaultValue(); |
| if (arg.getMode() != Mode.BOOLEAN || v.equals(Boolean.TRUE)) { |
| value = v.toString(); |
| } |
| } |
| if (!value.isEmpty()) { |
| value = " [Default: " + value + "]"; |
| } |
| } |
| |
| // Java doesn't support * for printf variable width, so we'll insert the long arg |
| // width "manually" in the printf format string. |
| String longArgWidth = Integer.toString(longArgLen + 2); |
| |
| // Print a line in the form " -1_letter_arg --long_arg description" |
| // where either the 1-letter arg or the long arg are optional. |
| String output = String.format( |
| " %1$-2s %2$-" + longArgWidth + "s: %3$s%4$s%5$s", //$NON-NLS-1$ //$NON-NLS-2$ |
| !arg.getShortArg().isEmpty() ? |
| "-" + arg.getShortArg() : //$NON-NLS-1$ |
| "", //$NON-NLS-1$ |
| !arg.getLongArg().isEmpty() ? |
| "--" + arg.getLongArg() : //$NON-NLS-1$ |
| "", //$NON-NLS-1$ |
| arg.getDescription(), |
| value, |
| required); |
| stdout(output); |
| numOptions++; |
| } |
| } |
| |
| if (numOptions == 0) { |
| stdout(" No options"); |
| } |
| } |
| |
| //---- |
| |
| protected enum Accept { |
| CONTINUE, |
| ACCEPT_AND_STOP, |
| REJECT_AND_STOP, |
| } |
| |
| /** |
| * The mode of an argument specifies the type of variable it represents, |
| * whether an extra parameter is required after the flag and how to parse it. |
| */ |
| protected enum Mode { |
| /** Argument value is a Boolean. Default value is a Boolean. */ |
| BOOLEAN { |
| @Override |
| public boolean needsExtra() { |
| return false; |
| } |
| @Override |
| public Object process(Arg arg, String extra) { |
| // Toggle the current value |
| arg.setCurrentValue(! ((Boolean) arg.getCurrentValue()).booleanValue()); |
| return Accept.ACCEPT_AND_STOP; |
| } |
| }, |
| |
| /** Argument value is an Integer. Default value is an Integer. */ |
| INTEGER { |
| @Override |
| public boolean needsExtra() { |
| return true; |
| } |
| @Override |
| public Object process(Arg arg, String extra) { |
| try { |
| arg.setCurrentValue(Integer.parseInt(extra)); |
| return null; |
| } catch (NumberFormatException e) { |
| return String.format("Failed to parse '%1$s' as an integer: %2$s", extra, |
| e.getMessage()); |
| } |
| } |
| }, |
| |
| /** Argument value is a String. Default value is a String[]. */ |
| ENUM { |
| @Override |
| public boolean needsExtra() { |
| return true; |
| } |
| @Override |
| public Object process(Arg arg, String extra) { |
| StringBuilder desc = new StringBuilder(); |
| String[] values = (String[]) arg.getDefaultValue(); |
| for (String value : values) { |
| if (value.equals(extra)) { |
| arg.setCurrentValue(extra); |
| return Accept.ACCEPT_AND_STOP; |
| } |
| |
| if (desc.length() != 0) { |
| desc.append(", "); |
| } |
| desc.append(value); |
| } |
| |
| return String.format("'%1$s' is not one of %2$s", extra, desc.toString()); |
| } |
| }, |
| |
| /** Argument value is a String. Default value is a null. */ |
| STRING { |
| @Override |
| public boolean needsExtra() { |
| return true; |
| } |
| @Override |
| public Object process(Arg arg, String extra) { |
| arg.setCurrentValue(extra); |
| return Accept.ACCEPT_AND_STOP; |
| } |
| }, |
| |
| /** Argument value is a {@link List}<String>. Default value is an empty list. */ |
| STRING_ARRAY { |
| @Override |
| public boolean needsExtra() { |
| return true; |
| } |
| @Override |
| public Object process(Arg arg, String extra) { |
| // For simplification, a string array doesn't accept something that |
| // starts with a dash unless a pure -- was seen before. |
| if (extra != null) { |
| Object v = arg.getCurrentValue(); |
| if (v == null) { |
| ArrayList<String> a = new ArrayList<String>(); |
| arg.setCurrentValue(a); |
| v = a; |
| } |
| if (v instanceof List<?>) { |
| @SuppressWarnings("unchecked") List<String> a = (List<String>) v; |
| |
| if (extra.equals("--") || |
| !extra.startsWith("-") || |
| (extra.startsWith("-") && a.contains("--"))) { |
| a.add(extra); |
| return Accept.CONTINUE; |
| } else if (a.isEmpty()) { |
| return "No values provided"; |
| } |
| } |
| } |
| return Accept.REJECT_AND_STOP; |
| } |
| }; |
| |
| /** |
| * Returns true if this mode requires an extra parameter. |
| */ |
| public abstract boolean needsExtra(); |
| |
| /** |
| * Processes the flag for this argument. |
| * |
| * @param arg The argument being processed. |
| * @param extra The extra parameter. Null if {@link #needsExtra()} returned false. |
| * @return {@link Accept#CONTINUE} if this argument can use multiple values and |
| * wishes to receive more. |
| * Or {@link Accept#ACCEPT_AND_STOP} if this was the last value accepted by the argument. |
| * Or {@link Accept#REJECT_AND_STOP} if this was value was reject and the argument |
| * stops accepting new values with no error. |
| * Or a string in case of error. |
| * Never returns null. |
| */ |
| public abstract Object process(Arg arg, String extra); |
| } |
| |
| /** |
| * An argument accepted by the command-line, also called "a flag". |
| * Arguments must have a short version (one letter), a long version name and a description. |
| * They can have a default value, or it can be null. |
| * Depending on the {@link Mode}, the default value can be a Boolean, an Integer, a String |
| * or a String array (in which case the first item is the current by default.) |
| */ |
| protected static class Arg { |
| /** Verb for that argument. Never null. */ |
| private final String mVerb; |
| /** Direct Object for that argument. Never null, but can be empty string. */ |
| private final String mDirectObject; |
| /** The 1-letter short name of the argument, e.g. -v. */ |
| private final String mShortName; |
| /** The long name of the argument, e.g. --verbose. */ |
| private final String mLongName; |
| /** A description. Never null. */ |
| private final String mDescription; |
| /** A default value. Can be null. */ |
| private final Object mDefaultValue; |
| /** The argument mode (type + process method). Never null. */ |
| private final Mode mMode; |
| /** True if this argument is mandatory for this verb/directobject. */ |
| private final boolean mMandatory; |
| /** Current value. Initially set to the default value. */ |
| private Object mCurrentValue; |
| /** True if the argument has been used on the command line. */ |
| private boolean mInCommandLine; |
| |
| /** |
| * Creates a new argument flag description. |
| * |
| * @param mode The {@link Mode} for the argument. |
| * @param mandatory True if this argument is mandatory for this action. |
| * @param verb The verb name. Never null. Can be {@link CommandLineParser#GLOBAL_FLAG_VERB}. |
| * @param directObject The action name. Can be {@link CommandLineParser#NO_VERB_OBJECT}. |
| * @param shortName The one-letter short argument name. Can be empty but not null. |
| * @param longName The long argument name. Can be empty but not null. |
| * @param description The description. Cannot be null. |
| * @param defaultValue The default value (or values), which depends on the selected |
| * {@link Mode}. Can be null. |
| */ |
| public Arg(Mode mode, |
| boolean mandatory, |
| @NonNull String verb, |
| @NonNull String directObject, |
| @NonNull String shortName, |
| @NonNull String longName, |
| @NonNull String description, |
| @Nullable Object defaultValue) { |
| mMode = mode; |
| mMandatory = mandatory; |
| mVerb = verb; |
| mDirectObject = directObject; |
| mShortName = shortName; |
| mLongName = longName; |
| mDescription = description; |
| mDefaultValue = defaultValue; |
| mInCommandLine = false; |
| if (defaultValue instanceof String[]) { |
| mCurrentValue = ((String[])defaultValue)[0]; |
| } else { |
| mCurrentValue = mDefaultValue; |
| } |
| } |
| |
| /** Return true if this argument is mandatory for this verb/directobject. */ |
| public boolean isMandatory() { |
| return mMandatory; |
| } |
| |
| /** Returns the 1-letter short name of the argument, e.g. -v. */ |
| public String getShortArg() { |
| return mShortName; |
| } |
| |
| /** Returns the long name of the argument, e.g. --verbose. */ |
| public String getLongArg() { |
| return mLongName; |
| } |
| |
| /** Returns the description. Never null. */ |
| public String getDescription() { |
| return mDescription; |
| } |
| |
| /** Returns the verb for that argument. Never null. */ |
| public String getVerb() { |
| return mVerb; |
| } |
| |
| /** Returns the direct Object for that argument. Never null, but can be empty string. */ |
| public String getDirectObject() { |
| return mDirectObject; |
| } |
| |
| /** Returns the default value. Can be null. */ |
| public Object getDefaultValue() { |
| return mDefaultValue; |
| } |
| |
| /** Returns the current value. Initially set to the default value. Can be null. */ |
| public Object getCurrentValue() { |
| return mCurrentValue; |
| } |
| |
| /** Sets the current value. Can be null. */ |
| public void setCurrentValue(Object currentValue) { |
| mCurrentValue = currentValue; |
| } |
| |
| /** Returns the argument mode (type + process method). Never null. */ |
| public Mode getMode() { |
| return mMode; |
| } |
| |
| /** Returns true if the argument has been used on the command line. */ |
| public boolean isInCommandLine() { |
| return mInCommandLine; |
| } |
| |
| /** Sets if the argument has been used on the command line. */ |
| public void setInCommandLine(boolean inCommandLine) { |
| mInCommandLine = inCommandLine; |
| } |
| } |
| |
| /** |
| * Internal helper to define a new argument for a give action. |
| * |
| * @param mode The {@link Mode} for the argument. |
| * @param mandatory The argument is required (never if {@link Mode#BOOLEAN}) |
| * @param verb The verb name. Never null. Can be {@link CommandLineParser#GLOBAL_FLAG_VERB}. |
| * @param directObject The action name. Can be {@link CommandLineParser#NO_VERB_OBJECT}. |
| * @param shortName The one-letter short argument name. Can be empty but not null. |
| * @param longName The long argument name. Can be empty but not null. |
| * @param description The description. Cannot be null. |
| * @param defaultValue The default value (or values), which depends on the selected |
| * {@link Mode}. |
| */ |
| protected void define(Mode mode, |
| boolean mandatory, |
| @NonNull String verb, |
| @NonNull String directObject, |
| @NonNull String shortName, |
| @NonNull String longName, |
| @NonNull String description, |
| @Nullable Object defaultValue) { |
| assert verb != null; |
| assert(!(mandatory && mode == Mode.BOOLEAN)); // a boolean mode cannot be mandatory |
| |
| // We should always have at least a short or long name, ideally both but never none. |
| assert shortName != null; |
| assert longName != null; |
| assert !shortName.isEmpty() || !longName.isEmpty(); |
| |
| if (directObject == null) { |
| directObject = NO_VERB_OBJECT; |
| } |
| |
| String key = verb + '/' + directObject + '/' + longName; |
| mArguments.put(key, new Arg(mode, mandatory, |
| verb, directObject, shortName, longName, description, defaultValue)); |
| } |
| |
| /** |
| * Exits in case of error. |
| * This is protected so that it can be overridden in unit tests. |
| */ |
| protected void exit() { |
| System.exit(1); |
| } |
| |
| /** |
| * Prints a line to stdout. |
| * This is protected so that it can be overridden in unit tests. |
| * |
| * @param format The string to be formatted. Cannot be null. |
| * @param args Format arguments. |
| */ |
| protected void stdout(String format, Object...args) { |
| String output = String.format(format, args); |
| output = LineUtil.reflowLine(output); |
| mLog.info("%s\n", output); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Prints a line to stderr. |
| * This is protected so that it can be overridden in unit tests. |
| * |
| * @param format The string to be formatted. Cannot be null. |
| * @param args Format arguments. |
| */ |
| protected void stderr(String format, Object...args) { |
| mLog.error(null, format, args); |
| } |
| |
| /** |
| * Returns the logger object. |
| * @return the logger object. |
| */ |
| protected ILogger getLog() { |
| return mLog; |
| } |
| } |
