/*
* Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.max.program.option;
import java.io.*;
import java.net.*;
import java.util.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import com.sun.max.*;
import com.sun.max.lang.*;
import com.sun.max.program.*;
import com.sun.max.program.option.gui.*;
/**
* The {@code OptionSet} class parses and collects options from the command line and
* configuration files.
*/
public class OptionSet {
/**
* The {@code Syntax} enum allows different options to be parsed differently,
* depending on their usage.
*/
public enum Syntax {
REQUIRES_EQUALS {
@Override
public String getUsage(Option option) {
return "-" + option.getName() + "=" + option.getType().getValueFormat();
}
},
EQUALS_OR_BLANK {
@Override
public String getUsage(Option option) {
return "-" + option.getName() + "[=" + option.getType().getValueFormat() + "]";
}
},
REQUIRES_BLANK {
@Override
public String getUsage(Option option) {
return "-" + option.getName();
}
},
CONSUMES_NEXT {
@Override
public String getUsage(Option option) {
return "-" + option.getName() + " " + option.getType().getValueFormat();
}
};
public abstract String getUsage(Option option);
}
protected final Map<String, Option> optionMap;
protected final Map<String, Syntax> optionSyntax;
protected final Map<String, String> optionValues;
protected final boolean allowUnrecognizedOptions;
protected static final String[] NO_ARGUMENTS = {};
protected String[] arguments = NO_ARGUMENTS;
/**
* Creates an option set that does not allow unrecognized options to be present when
* {@linkplain #parseArguments(String[]) parsing command line arguments} or
* {@linkplain #loadOptions(OptionSet) loading options from another option set}.
*/
public OptionSet() {
this(false);
}
/**
* Creates an option set.
*
* @param allowUnrecognizedOptions
* specifies if this option set allows unrecognized options to be present when
* {@linkplain #parseArguments(String[]) parsing command line arguments} or
* {@linkplain #loadOptions(OptionSet) loading options from another option set}.
*/
public OptionSet(boolean allowUnrecognizedOptions) {
optionValues = new HashMap<String, String>();
// Using a LinkedHashMap to preserve insertion order when iterating over values
optionMap = new LinkedHashMap<String, Option>();
optionSyntax = new HashMap<String, Syntax>();
this.allowUnrecognizedOptions = allowUnrecognizedOptions;
}
/**
* Converts this option set into a list of command line arguments, to be used, for example, to pass to an external
* tool. For each option in this set that has been explicitly set this method will prepend an appropriate option
* string of appropriate syntactic form (e.g. "-name=value") to the array of arguments passed.
*
* @return a new array of program arguments that includes these options
*/
public String[] asArguments() {
String[] newArgs = Arrays.copyOf(arguments, arguments.length + optionValues.size());
int i = 0;
for (String name : optionValues.keySet()) {
final String value = optionValues.get(name);
final Syntax syntax = optionSyntax.get(name);
if (syntax == Syntax.REQUIRES_BLANK) {
newArgs[i++] = "-" + name;
} else if (syntax == Syntax.CONSUMES_NEXT) {
newArgs = Arrays.copyOf(newArgs, newArgs.length + 1);
newArgs[i++] = "-" + name;
newArgs[i++] = value;
} else {
newArgs[i++] = "-" + name + "=" + value;
}
}
return newArgs;
}
/**
* Gets an option set derived from this option set that contains all the unrecognized options that have been loaded
* or parsed into this option set. The returned option set also includes a copy of the
* {@linkplain #getArguments() non-option arguments} from this option set.
* @return a new option set encapsulating all the arguments and options
*/
public OptionSet getArgumentsAndUnrecognizedOptions() {
final OptionSet argumentsAndUnrecognizedOptions = new OptionSet(true);
for (Map.Entry<String, String> entry : optionValues.entrySet()) {
if (!optionMap.containsKey(entry.getKey())) {
argumentsAndUnrecognizedOptions.optionValues.put(entry.getKey(), entry.getValue());
}
}
argumentsAndUnrecognizedOptions.arguments = arguments;
return argumentsAndUnrecognizedOptions;
}
/**
* Handles an Option.Error raised while loading or parsing values into this option set.
* <p>
* This default implementation is to print a usage message and the call {@link System#exit(int)}.
* @param error the error that occurred
* @param optionName the name of the option being parsed
*/
protected void handleErrorDuringParseOrLoad(Option.Error error, String optionName) {
System.out.println("Error parsing option -" + optionName + ": " + error.getMessage());
printHelp(System.out, 78);
System.exit(1);
}
/**
* Parses a list of command line arguments, processing the leading options (i.e. arguments that start with '-')
* and returning the "leftover" arguments to the caller. The longest tail of {@code arguments} that starts with a non-option argument can be retrieved after parsing with {@link #getArguments()}.
*
* @param args
* the arguments
* @return this option set
*/
public OptionSet parseArguments(String[] args) {
// parse the options
int i = 0;
for (; i < args.length; i++) {
final String argument = args[i];
if (argument.charAt(0) == '-') {
// is the beginning of a valid option.
final int index = argument.indexOf('=');
final String optionName = getOptionName(argument, index);
String value = getOptionValue(argument, index);
final Syntax syntax = optionSyntax.get(optionName);
// check the syntax of this option
try {
checkSyntax(optionName, syntax, value);
if (syntax == Syntax.CONSUMES_NEXT) {
value = args[++i];
}
setValue(optionName, value);
} catch (Option.Error error) {
handleErrorDuringParseOrLoad(error, optionName);
}
} else {
// is not an option, therefore the start of arguments
break;
}
}
final int left = args.length - i;
arguments = new String[left];
System.arraycopy(args, i, arguments, 0, left);
if (System.getProperty("useProgramOptionDialog") != null) {
OptionsDialog.show(null, this);
}
return this;
}
/**
* The {@code getArguments()} method gets the leftover command line options
* from the last call to {@code parseArguments}.
*
* @return the leftover command line options
*/
public String[] getArguments() {
if (arguments.length == 0) {
return arguments;
}
return Arrays.copyOf(arguments, arguments.length);
}
/**
* Determines if this option set allows parsing or loading of unrecognized options.
* @return {@code true} if this option set allows unrecognized options
*/
public boolean allowsUnrecognizedOptions() {
return allowUnrecognizedOptions;
}
/**
* The {@code loadSystemProperties()} method loads the value of the valid
* options from the systems properties with the specified prefix.
*
* @param prefix the prefix of each system property, used to disambiguate
* these options from other system properties.
* @return this option set
*/
public OptionSet loadSystemProperties(String prefix) {
final Properties systemProperties = System.getProperties();
final Properties properties = new Properties();
for (String key : systemProperties.stringPropertyNames()) {
if (key.startsWith(prefix)) {
properties.setProperty(key.substring(prefix.length()), systemProperties.getProperty(key));
}
}
return loadProperties(properties, true);
}
/**
* The {@code storeSystemProperties()} method stores these option values
* into the system properties.
*
* @param prefix the prefix to append to all option names when inserting them
* into the systems properties
*/
public void storeSystemProperties(String prefix) {
for (Map.Entry<String, String> entry : optionValues.entrySet()) {
System.setProperty(prefix + entry.getKey(), entry.getValue());
}
}
/**
* Loads the specified properties into this set of options.
*
* @param p
* the properties set to load into this set of options
* @param loadall
* true if this method should load all properties in the property set into this option set; false if this
* method should only load properties for options already in this option set
* @return this option set
*/
public OptionSet loadProperties(Properties p, boolean loadall) {
if (loadall) {
// if loadall is specified, load all properties in the set
for (Object object : p.keySet()) {
final String name = (String) object;
final String val = p.getProperty(name);
try {
setValue(name, val);
} catch (Option.Error error) {
handleErrorDuringParseOrLoad(error, name);
}
}
} else {
// if loadall is not specified, only load options that are in this option set.
for (Object o : p.keySet()) {
final String name = (String) o;
if (optionMap.containsKey(name)) {
final String val = p.getProperty(name);
try {
setValue(name, val);
} catch (Option.Error error) {
handleErrorDuringParseOrLoad(error, name);
}
}
}
}
if (System.getProperty("useProgramOptionDialog") != null) {
OptionsDialog.show(null, this);
}
return this;
}
/**
* The {@code loadFile()} method parses properties from a file and loads them into this set of options.
*
* @param fname
* the filename from while to load the properties
* @param loadall
* true if this method should load all properties in the property set into this option set; false if this
* method should only load properties for options already in this option set
* @return this option set
* @throws java.io.IOException
* if there is a problem opening or reading the file
* @throws Option.Error
* if there is a problem parsing an option
*/
public OptionSet loadFile(String fname, boolean loadall) throws IOException, Option.Error {
final Properties defs = new Properties();
final FileInputStream stream = new FileInputStream(new File(fname));
defs.load(stream);
stream.close();
return loadProperties(defs, loadall);
}
/**
* Loads a set of options and {@linkplain #getArguments() arguments} from another option set.
*
* @param options the option set from which to load the option values
* @return this option set
*/
public OptionSet loadOptions(OptionSet options) {
for (Map.Entry<String, String> entry : options.optionValues.entrySet()) {
try {
setValue(entry.getKey(), entry.getValue());
} catch (Option.Error error) {
handleErrorDuringParseOrLoad(error, entry.getKey());
}
}
arguments = options.arguments;
if (System.getProperty("useProgramOptionDialog") != null) {
OptionsDialog.show(null, this);
}
return this;
}
protected void checkSyntax(String optname, Syntax syntax, String value) {
if (syntax == Syntax.REQUIRES_BLANK && value != null) {
throw new Option.Error("syntax error: \"-" + optname + "\" required");
}
if (syntax == Syntax.REQUIRES_EQUALS && value == null) {
throw new Option.Error("syntax error: \"-" + optname + "=value\" required");
}
if (syntax == Syntax.CONSUMES_NEXT && value != null) {
throw new Option.Error("syntax error: \"-" + optname + " value\" required");
}
}
protected String getOptionName(String argument, int equalIndex) {
if (equalIndex < 0) { // naked option
return argument.substring(1, argument.length());
}
return argument.substring(1, equalIndex);
}
protected String getOptionValue(String argument, int equalIndex) {
if (equalIndex < 0) { // naked option
return null;
}
return argument.substring(equalIndex + 1);
}
/**
* Adds the options of an {@link OptionSet} to this set.
* @param optionSet the set of options to add
*/
public void addOptions(OptionSet optionSet) {
for (Option<?> option : optionSet.getOptions()) {
final Syntax syntax = optionSet.optionSyntax.get(option.getName());
addOption(option, syntax);
}
}
/**
* The {@code addOption()} method adds an option with the {@link Syntax#REQUIRES_EQUALS} syntax to this option set.
*
* @param option the new option to add to this set
* @return the option passed as the argument, after it has been added to this option set
*/
public <T> Option<T> addOption(Option<T> option) {
return addOption(option, Syntax.REQUIRES_EQUALS);
}
/**
* The {@code addOption()} method adds an option to this option set.
*
* @param option the new option to add to this set
* @param syntax the syntax of the option, which specifies how to parse the option
* from command line parameters
* @return the option passed as the argument, after it has been added to this option set
*/
public <T> Option<T> addOption(Option<T> option, Syntax syntax) {
final String name = option.getName();
final Option existingOption = optionMap.put(name, option);
if (existingOption != null) {
throw ProgramError.unexpected("Cannot register more than one option under the same name: " + option.getName());
}
optionSyntax.put(name, syntax);
return option;
}
/**
* The {@code setSyntax()} method sets the syntax of a particular option.
*
* @param option the option for which to change the syntax
* @param syntax the new syntax for the instruction
*/
public void setSyntax(Option option, Syntax syntax) {
optionSyntax.put(option.getName(), syntax);
}
/**
* The {@code setValue()} method sets the value of the specified option in
* this option set. If there is no option by the specified name, the name/value
* pair will simply be remembered.
*
* @param name the name of the option
* @param value the new value of the option as a string
* @throws Option.Error if {@code name} denotes an unrecognized option and this
*/
public void setValue(String name, String value) {
final String v = value == null ? "" : value;
final Option opt = optionMap.get(name);
if (opt != null) {
opt.setString(v);
} else {
if (!allowUnrecognizedOptions) {
throw new Option.Error("unrecognized option -" + name);
}
}
optionValues.put(name, v);
}
public void setValuesAgain() {
for (String name : optionValues.keySet()) {
final Option opt = optionMap.get(name);
opt.setString(optionValues.get(name));
}
}
public String getStringValue(String name) {
return optionValues.get(name);
}
/**
* The {@code hasOptionSpecified()} method checks whether an option with the specified
* name has been assigned to. An option as been "assigned to" if its value has been set
* by either parsing arguments (the {@code parseArguments() method} or loading properties
* from a file or the system properties.
*
* @param name the name of the option to query
* @return true if an option with the specified name has been set; false otherwise
*/
public boolean hasOptionSpecified(String name) {
return optionValues.containsKey(name);
}
/**
* Retrieves the options from this option
* set, in the order in which they were added.
* @return an iterable collection of {@code Option} instances, sorted according to insertion order
*/
public Iterable<Option<?>> getOptions() {
return Utils.cast(optionMap.values());
}
/**
* The {@code getSortedOptions()} method retrieves the options from this option
* set, sorting all options by their names.
* @return an iterable collection of {@code Option} instances, sorted according to the name of each option
*/
public Iterable<Option<?>> getSortedOptions() {
final List<Option<?>> list = new LinkedList<Option<?>>();
final TreeSet<String> tree = new TreeSet<String>();
for (String string : optionMap.keySet()) {
tree.add(string);
}
for (String string : tree) {
list.add(optionMap.get(string));
}
return list;
}
/**
* Prints the help message header.
*
* @param stream the output stream to which to write the help text
*/
protected void printHelpHeader(PrintStream stream) {
}
/**
* The {@code printHelp()} method prints a textual listing of these options and their syntax
* to the specified output stream.
* @param stream the output stream to which to write the help text
* @param width the length of the line to truncate
*/
public void printHelp(PrintStream stream, int width) {
printHelpHeader(stream);
for (Option<?> option : getSortedOptions()) {
if (option.type == OptionTypes.BLANK_BOOLEAN_TYPE && option instanceof FieldOption) {
FieldOption fopt = (FieldOption) option;
try {
if (!fopt.nullValue.equals(fopt.field.getBoolean(null))) {
// Don't show message for "-XX:+<opt>" option if the default is represented by the
// "-XX:-<opt>" option instead (and vice versa).
continue;
}
} catch (Exception e) {
}
}
final Option<Object> opt = Utils.cast(option);
stream.print(" " + getUsage(opt));
final Object defaultValue = opt.getDefaultValue();
if (defaultValue != null) {
stream.println(" (default: " + opt.getType().unparseValue(defaultValue) + ")");
} else {
stream.println();
}
final String help = opt.getHelp();
if (help.length() > 0) {
stream.print(Strings.formatParagraphs(help, 8, 0, width));
stream.println();
}
}
}
/**
* Prints a textual listing of these options and their values
* to the specified output stream.
* @param stream the output stream to which to write the text
* @param indent the number of spaces to indent
* @param verbose add each option's description when true
*/
public void printValues(PrintStream stream, int indent, boolean verbose) {
final String indentation = Strings.times(' ', indent);
for (Option<?> option : getSortedOptions()) {
if (option.type == OptionTypes.BLANK_BOOLEAN_TYPE && option instanceof FieldOption) {
FieldOption fopt = (FieldOption) option;
try {
if (!fopt.nullValue.equals(fopt.field.getBoolean(null))) {
// Don't show message for "-XX:+<opt>" option if the default is represented by the
// "-XX:-<opt>" option instead (and vice versa).
continue;
}
} catch (Exception e) {
}
}
final Option<Object> opt = Utils.cast(option);
stream.print(indentation + opt.getName() + ": " + opt.getValue());
if (verbose) {
stream.println(opt.isAssigned() ? "" : " (default)");
stream.println(" " + opt.getHelp());
stream.println(" " + getUsage(opt));
}
stream.println();
}
}
/**
* This method gets a usage string for a particular option that describes
* the range of valid string values that it accepts.
* @param option the option for which to get usage
* @return a string describing the usage syntax for the specified option
*/
public String getUsage(Option option) {
return optionSyntax.get(option.getName()).getUsage(option);
}
/**
* This method adds all public static fields with appropriate types to the
* option set with the specified prefix.
* @param javaClass the java class containing the fields
* @param prefix the prefix to add to the options
* @param helpMap map from option names to the help message for the option (may be {@code null})
*/
public void addFieldOptions(Class<?> javaClass, String prefix, Map<String, String> helpMap) {
for (final Field field : javaClass.getDeclaredFields()) {
int modifiers = field.getModifiers();
if (Modifier.isStatic(modifiers) && !Modifier.isFinal(modifiers)) {
field.setAccessible(true);
final OptionSettings settings = field.getAnnotation(OptionSettings.class);
String help;
String name;
if (settings != null) {
help = settings.help();
name = settings.name().isEmpty() ? field.getName().replace('_', '-') : settings.name();
} else {
name = field.getName().replace('_', '-');
help = helpMap != null ? helpMap.get(name) : "";
if (help == null) {
help = "";
}
}
addFieldOption(prefix, name, null, field, help);
}
}
}
/**
* Adds a new option whose value is stored in the specified reflection field.
* @param prefix the name of the option
* @param name the name of the option
* @param object the object containing the field (if the field is not static)
* @param field the field to store the value
* @param help the help text for the option @return a new option that will modify the field when parsed
* @return the option created
*/
@SuppressWarnings("unchecked")
public Option<?> addFieldOption(String prefix, String name, Object object, Field field, String help) {
final Class<?> fieldType = field.getType();
final Object defaultValue;
final String optionName = prefix + ":" + name;
try {
defaultValue = field.get(null);
} catch (IllegalAccessException e) {
return null;
}
if (fieldType == boolean.class) {
if (prefix.length() > 0) {
// setup a "-prefix+name" option
String plusName = prefix + ":+" + name;
FieldOption<Boolean> plusOption = new FieldOption<Boolean>(plusName, object, field, (Boolean) defaultValue, OptionTypes.BLANK_BOOLEAN_TYPE, help);
plusOption.nullValue = true;
addOption(plusOption, Syntax.REQUIRES_BLANK);
// setup a "-prefix-name" option
String minusName = prefix + ":-" + name;
FieldOption<Boolean> minusOption = new FieldOption<Boolean>(minusName, object, field, (Boolean) defaultValue, OptionTypes.BLANK_BOOLEAN_TYPE, help);
minusOption.nullValue = false;
return addOption(minusOption, Syntax.REQUIRES_BLANK);
}
return addOption(new FieldOption<Boolean>(optionName, object, field, (Boolean) defaultValue, OptionTypes.BOOLEAN_TYPE, help));
} else if (fieldType == int.class) {
return addOption(new FieldOption<Integer>(optionName, object, field, (Integer) defaultValue, OptionTypes.INT_TYPE, help));
} else if (fieldType == float.class) {
return addOption(new FieldOption<Float>(optionName, object, field, (Float) defaultValue, OptionTypes.FLOAT_TYPE, help));
} else if (fieldType == long.class) {
return addOption(new FieldOption<Long>(optionName, object, field, (Long) defaultValue, OptionTypes.LONG_TYPE, help));
} else if (fieldType == double.class) {
return addOption(new FieldOption<Double>(optionName, object, field, (Double) defaultValue, OptionTypes.DOUBLE_TYPE, help));
} else if (fieldType == String.class) {
return addOption(new FieldOption<String>(optionName, object, field, (String) defaultValue, OptionTypes.STRING_TYPE, help));
} else if (fieldType == File.class) {
return addOption(new FieldOption<File>(optionName, object, field, (File) defaultValue, OptionTypes.FILE_TYPE, help));
} else if (fieldType.isEnum()) {
final Class<? extends Enum> enumClass = Utils.cast(fieldType);
return addOption(makeEnumFieldOption(optionName, object, field, defaultValue, enumClass, help));
}
return null;
}
private <T extends Enum<T>> FieldOption<T> makeEnumFieldOption(String name, Object object, Field field, Object defaultValue, Class<T> enumClass, String help) {
final OptionTypes.EnumType<T> optionType = new OptionTypes.EnumType<T>(enumClass);
final T defaultV = Utils.<T>cast(defaultValue);
return new FieldOption<T>(name, object, field, defaultV, optionType, help);
}
public Option<String> newStringOption(String name, String defaultValue, String help) {
return addOption(new Option<String>(name, defaultValue, OptionTypes.STRING_TYPE, help));
}
public Option<Integer> newIntegerOption(String name, Integer defaultValue, String help) {
return addOption(new Option<Integer>(name, defaultValue, OptionTypes.INT_TYPE, help));
}
public Option<Long> newLongOption(String name, Long defaultValue, String help) {
return addOption(new Option<Long>(name, defaultValue, OptionTypes.LONG_TYPE, help));
}
public Option<Float> newFloatOption(String name, Float defaultValue, String help) {
return addOption(new Option<Float>(name, defaultValue, OptionTypes.FLOAT_TYPE, help));
}
public Option<Double> newDoubleOption(String name, Double defaultValue, String help) {
return addOption(new Option<Double>(name, defaultValue, OptionTypes.DOUBLE_TYPE, help));
}
public Option<List<String>> newStringListOption(String name, String defaultValue, String help) {
return addOption(new Option<List<String>>(name, defaultValue == null ? null : OptionTypes.COMMA_SEPARATED_STRING_LIST_TYPE.parseValue(defaultValue), OptionTypes.COMMA_SEPARATED_STRING_LIST_TYPE, help));
}
public Option<List<String>> newStringListOption(String name, String[] defaultValue, String help) {
List<String> list = null;
if (defaultValue != null) {
list = new ArrayList<String>(defaultValue.length);
list.addAll(Arrays.asList(defaultValue));
}
return addOption(new Option<List<String>>(name, list, OptionTypes.COMMA_SEPARATED_STRING_LIST_TYPE, help));
}
public Option<List<String>> newStringListOption(String name, String defaultValue, char separator, String help) {
final OptionTypes.StringListType type = new OptionTypes.StringListType(separator);
return addOption(new Option<List<String>>(name, defaultValue == null ? null : type.parseValue(defaultValue), type, help));
}
public <T> Option<List<T>> newListOption(String name, String defaultValue, Option.Type<T> elementOptionType, char separator, String help) {
final OptionTypes.ListType<T> type = new OptionTypes.ListType<T>(separator, elementOptionType);
return addOption(new Option<List<T>>(name, defaultValue == null ? null : type.parseValue(defaultValue), type, help));
}
public Option<File> newFileOption(String name, String defaultValue, String help) {
return newFileOption(name, OptionTypes.FILE_TYPE.parseValue(defaultValue), help);
}
public Option<File> newFileOption(String name, File defaultValue, String help) {
return addOption(new Option<File>(name, defaultValue, OptionTypes.FILE_TYPE, help));
}
public Option<URL> newURLOption(String name, URL defaultValue, String help) {
return addOption(new Option<URL>(name, defaultValue, OptionTypes.URL_TYPE, help));
}
public <T> Option<T> newInstanceOption(String name, Class<T> klass, T defaultValue, String help) {
return addOption(new Option<T>(name, defaultValue, OptionTypes.createInstanceOptionType(klass), help));
}
public <T> Option<List<T>> newListInstanceOption(String name, String defaultValue, Class<T> klass, char separator, String help) {
final OptionTypes.ListType<T> type = OptionTypes.createInstanceListOptionType(klass, separator);
return addOption(new Option<List<T>>(name, (defaultValue == null) ? null : type.parseValue(defaultValue), type, help));
}
public Option<Boolean> newBooleanOption(String name, Boolean defaultValue, String help) {
if (defaultValue != null && !defaultValue) {
return addOption(new Option<Boolean>(name, defaultValue, OptionTypes.BOOLEAN_TYPE, help), Syntax.EQUALS_OR_BLANK);
}
return addOption(new Option<Boolean>(name, defaultValue, OptionTypes.BOOLEAN_TYPE, help));
}
public <T> Option<T> newOption(String name, String defaultValue, Option.Type<T> type, String help) {
return newOption(name, type.parseValue(defaultValue), type, Syntax.REQUIRES_EQUALS, help);
}
public <T> Option<T> newOption(String name, T defaultValue, Option.Type<T> type, Syntax syntax, String help) {
return addOption(new Option<T>(name, defaultValue, type, help), syntax);
}
public <E extends Enum<E>> Option<E> newEnumOption(String name, E defaultValue, Class<E> enumClass, String help) {
return addOption(new Option<E>(name, defaultValue, new OptionTypes.EnumType<E>(enumClass), help));
}
public <E extends Enum<E>> Option<List<E>> newEnumListOption(String name, Iterable<E> defaultValue, Class<E> enumClass, String help) {
final List<E> list;
if (defaultValue == null) {
list = null;
} else if (defaultValue instanceof List) {
list = Utils.cast(defaultValue);
} else if (defaultValue instanceof Collection) {
final Collection<E> collection = Utils.cast(defaultValue);
list = new ArrayList<E>(collection);
} else {
list = new ArrayList<E>();
for (E value : defaultValue) {
list.add(value);
}
}
final Option<List<E>> option = new Option<List<E>>(name, list, new OptionTypes.EnumListType<E>(enumClass, ','), help);
return addOption(option);
}
public Option<File> newConfigOption(String name, File defaultFile, String help) {
return addOption(new Option<File>(name, defaultFile, new OptionTypes.ConfigFile(this), help));
}
}