Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.uli.util; import org.apache.commons.cli.Option; /** * MyOptionBuilder is derived from: * OptionBuilder allows the user to create Options using descriptive methods. * * <p>Details on the Builder pattern can be found at * <a href="http://c2.com/cgi-bin/wiki?BuilderPattern"> * http://c2.com/cgi-bin/wiki?BuilderPattern</a>.</p> * * @author John Keyes (john at integralsource.com) * @version $Revision: 754830 $, $Date: 2009-03-16 00:26:44 -0700 (Mon, 16 Mar 2009) $ * @since 1.0 * * Basically, I'd like to get rid of warnings like these: * * .../src/main/java/org/uli/htmlunescape/Main.java:50: warning: [static] static method should be qualified by type name, OptionBuilder, instead of by an expression * .create("h"); * * You'll get them when you use the OptionBuilder like this: * * Option lp = OptionBuilder.withArgName("hostname") * .hasArg(true) * .isRequired(true) * .withDescription("host") * .withLongOpt("host") * .create("h"); * * With MyOptionBuilder, you'll do it like this: * * Option lp = MyOptionBuilder.init().withArgName("hostname") * .hasArg(true) * .isRequired(true) * .withDescription("host") * .withLongOpt("host") * .create("h"); * * There will be no warning. All you have to do is * * * use MyOptionBuilder instead of OptionBuilder * * add the init() call */ public final class MyOptionBuilder { /** long option */ private String longopt; /** option description */ private String description; /** argument name */ private String argName; /** is required? */ private boolean required; /** the number of arguments */ private int numberOfArgs = Option.UNINITIALIZED; /** option type */ private Object type; /** option can have an optional argument value */ private boolean optionalArg; /** value separator for argument value */ private char valuesep; /** option builder instance */ //private MyOptionBuilder instance = new MyOptionBuilder(); /** * private constructor to prevent instances being created */ private MyOptionBuilder() { // hide the constructor } static public MyOptionBuilder init() { return new MyOptionBuilder(); } /** * Resets the member variables to their default values. */ private void reset() { description = null; argName = "arg"; longopt = null; type = null; required = false; numberOfArgs = Option.UNINITIALIZED; // PMM 9/6/02 - these were missing optionalArg = false; valuesep = (char) 0; } /** * The next Option created will have the following long option value. * * @param newLongopt the long option value * @return the OptionBuilder instance */ public MyOptionBuilder withLongOpt(String newLongopt) { this.longopt = newLongopt; return this; } /** * The next Option created will require an argument value. * * @return the OptionBuilder instance */ public MyOptionBuilder hasArg() { this.numberOfArgs = 1; return this; } /** * The next Option created will require an argument value if * <code>hasArg</code> is true. * * @param hasArg if true then the Option has an argument value * @return the OptionBuilder instance */ public MyOptionBuilder hasArg(boolean hasArg) { this.numberOfArgs = hasArg ? 1 : Option.UNINITIALIZED; return this; } /** * The next Option created will have the specified argument value name. * * @param name the name for the argument value * @return the OptionBuilder instance */ public MyOptionBuilder withArgName(String name) { this.argName = name; return this; } /** * The next Option created will be required. * * @return the OptionBuilder instance */ public MyOptionBuilder isRequired() { this.required = true; return this; } /** * The next Option created uses <code>sep</code> as a means to * separate argument values. * * <b>Example:</b> * <pre> * Option opt = this.withValueSeparator(':') * .create('D'); * * CommandLine line = parser.parse(args); * String propertyName = opt.getValue(0); * String propertyValue = opt.getValue(1); * </pre> * * @param sep The value separator to be used for the argument values. * * @return the OptionBuilder instance */ public MyOptionBuilder withValueSeparator(char sep) { this.valuesep = sep; return this; } /** * The next Option created uses '<code>=</code>' as a means to * separate argument values. * * <b>Example:</b> * <pre> * Option opt = this.withValueSeparator() * .create('D'); * * CommandLine line = parser.parse(args); * String propertyName = opt.getValue(0); * String propertyValue = opt.getValue(1); * </pre> * * @return the OptionBuilder instance */ public MyOptionBuilder withValueSeparator() { this.valuesep = '='; return this; } /** * The next Option created will be required if <code>required</code> * is true. * * @param newRequired if true then the Option is required * @return the OptionBuilder instance */ public MyOptionBuilder isRequired(boolean newRequired) { this.required = newRequired; return this; } /** * The next Option created can have unlimited argument values. * * @return the OptionBuilder instance */ public MyOptionBuilder hasArgs() { this.numberOfArgs = Option.UNLIMITED_VALUES; return this; } /** * The next Option created can have <code>num</code> argument values. * * @param num the number of args that the option can have * @return the OptionBuilder instance */ public MyOptionBuilder hasArgs(int num) { this.numberOfArgs = num; return this; } /** * The next Option can have an optional argument. * * @return the OptionBuilder instance */ public MyOptionBuilder hasOptionalArg() { this.numberOfArgs = 1; this.optionalArg = true; return this; } /** * The next Option can have an unlimited number of optional arguments. * * @return the OptionBuilder instance */ public MyOptionBuilder hasOptionalArgs() { this.numberOfArgs = Option.UNLIMITED_VALUES; this.optionalArg = true; return this; } /** * The next Option can have the specified number of optional arguments. * * @param numArgs - the maximum number of optional arguments * the next Option created can have. * @return the OptionBuilder instance */ public MyOptionBuilder hasOptionalArgs(int numArgs) { this.numberOfArgs = numArgs; this.optionalArg = true; return this; } /** * The next Option created will have a value that will be an instance * of <code>type</code>. * * @param newType the type of the Options argument value * @return the OptionBuilder instance */ public MyOptionBuilder withType(Object newType) { this.type = newType; return this; } /** * The next Option created will have the specified description * * @param newDescription a description of the Option's purpose * @return the OptionBuilder instance */ public MyOptionBuilder withDescription(String newDescription) { this.description = newDescription; return this; } /** * Create an Option using the current settings and with * the specified Option <code>char</code>. * * @param opt the character representation of the Option * @return the Option instance * @throws IllegalArgumentException if <code>opt</code> is not * a valid character. See Option. */ public Option create(char opt) throws IllegalArgumentException { return create(String.valueOf(opt)); } /** * Create an Option using the current settings * * @return the Option instance * @throws IllegalArgumentException if <code>longOpt</code> has not been set. */ public Option create() throws IllegalArgumentException { if (longopt == null) { this.reset(); throw new IllegalArgumentException("must specify longopt"); } return create(null); } /** * Create an Option using the current settings and with * the specified Option <code>char</code>. * * @param opt the <code>java.lang.String</code> representation * of the Option * @return the Option instance * @throws IllegalArgumentException if <code>opt</code> is not * a valid character. See Option. */ public Option create(String opt) throws IllegalArgumentException { Option option = null; try { // create the option option = new Option(opt, description); // set the option properties option.setLongOpt(longopt); option.setRequired(required); option.setOptionalArg(optionalArg); option.setArgs(numberOfArgs); option.setType(type); option.setValueSeparator(valuesep); option.setArgName(argName); } finally { // reset the OptionBuilder properties this.reset(); } // return the Option instance return option; } }