From 7c7b9d023cd466c1771068badc020dab36beb553 Mon Sep 17 00:00:00 2001 From: Endi Sukma Dewata Date: Thu, 5 Apr 2012 14:49:11 -0500 Subject: Removed whitespaces from Java code. Whitespaces in Java code have been removed with the following command: find . -not -path .git -name *.java -exec sed -i 's/[[:blank:]]\+$//' {} \; Ticket #134 --- .../netscape/pkisilent/argparser/ArgParser.java | 294 ++++++++++----------- 1 file changed, 147 insertions(+), 147 deletions(-) (limited to 'base/silent/src/com/netscape/pkisilent/argparser/ArgParser.java') diff --git a/base/silent/src/com/netscape/pkisilent/argparser/ArgParser.java b/base/silent/src/com/netscape/pkisilent/argparser/ArgParser.java index ed5f98b1d..ecb6038df 100755 --- a/base/silent/src/com/netscape/pkisilent/argparser/ArgParser.java +++ b/base/silent/src/com/netscape/pkisilent/argparser/ArgParser.java @@ -23,7 +23,7 @@ package com.netscape.pkisilent.argparser; * copy, modify and redistribute is granted, provided that this copyright * notice is retained and the author is given credit whenever appropriate. * - * This software is distributed "as is", without any warranty, including + * This software is distributed "as is", without any warranty, including * any implied warranty of merchantability or fitness for a particular * use. The author assumes no responsibility for, and shall not be liable * for, any special, indirect, or consequential damages, or any damages @@ -54,36 +54,36 @@ import java.util.Vector; * reading arguments from a file. The * last feature is particularly useful and makes it * easy to create ad-hoc configuration files for an application. - * + * *

Basic Example

- * + * *

* Here is a simple example in which an application has three command line options: -theta (followed by a * floating point value), -file (followed by a string value), and -debug, which causes a * boolean value to be set. - * + * * 

- * 
+ *
  * static public void main(String[] args) {
  *     // create holder objects for storing results ...
- * 
+ *
  *     DoubleHolder theta = new DoubleHolder();
  *     StringHolder fileName = new StringHolder();
  *     BooleanHolder debug = new BooleanHolder();
- * 
+ *
  *     // create the parser and specify the allowed options ...
- * 
+ *
  *     ArgParser parser = new ArgParser("java argparser.SimpleExample");
  *     parser.addOption("-theta %f #theta value (in degrees)", theta);
  *     parser.addOption("-file %s #name of the operating file", fileName);
  *     parser.addOption("-debug %v #enables display of debugging info", debug);
- * 
+ *
  *     // match the arguments ...
- * 
+ *
  *     parser.matchAllArgs(args);
- * 
+ *
  *     // and print out the values
- * 
+ *
  *     System.out.println("theta=" + theta.value);
  *     System.out.println("fileName=" + fileName.value);
  *     System.out.println("debug=" + debug.value);
@@ -91,18 +91,18 @@ import java.util.Vector;
  *
*

* A command line specifying all three options might look like this: - * + * * 

  * java argparser.SimpleExample -theta 7.8 -debug -file /ai/lloyd/bar
  *
- * + * *

* The application creates an instance of ArgParser and then adds descriptions of the allowed options using * {@link #addOption addOption}. The method {@link #matchAllArgs(String[]) matchAllArgs} is then used to match these * options against the command line arguments. Values associated with each option are returned in the value * field of special ``holder'' classes (e.g., {@link argparser.DoubleHolder DoubleHolder}, * {@link argparser.StringHolder StringHolder}, etc.). - * + * *

* The first argument to {@link #addOption addOption} is a string that specifies (1) the option's name, (2) a conversion * code for its associated value (e.g., %f for floating point, %s for a string, @@ -112,15 +112,15 @@ import java.util.Vector; * {@link argparser.StringHolder * StringHolder}), an array of the appropriate type, or an instance of * java.util.Vector. - * + * *

* By default, arguments that don't match the specified options, are out of range, or are * otherwise formatted incorrectly, will cause matchAllArgs to print a message and exit the program. * Alternatively, an application can use {@link #matchAllArgs(String[],int,int) matchAllArgs(args,idx,exitFlags)} to * obtain an array of unmatched arguments which can then be processed separately - * + * *

Range Specification

- * + * * The values associated with options can also be given range specifications. A range specification appears in curly * braces immediately following the conversion code. In the code fragment below, we show how to specify an option * -name that expects to be provided with one of three string values (john, mary, @@ -128,129 +128,129 @@ import java.util.Vector; * to 256, an option -size that expects to be supplied with integer values of either 1, 2, 4, 8, or 16, and * an option -foo that expects to be supplied with floating point values in the ranges -99 < foo <= -50, or * 50 <= foo < 99. - * + * * 
  * StringHolder name = new StringHolder();
  * IntHolder index = new IntHolder();
  * IntHolder size = new IntHolder();
  * DoubleHolder foo = new DoubleHolder();
- * 
+ *
  * parser.addOption("-name %s {john,mary,jane}", name);
  * parser.addOption("-index %d {[1,256]}", index);
  * parser.addOption("-size %d {1,2,4,8,16}", size);
  * parser.addOption("-foo %f {(-99,-50],[50,99)}", foo);
  *
- * + * * If an argument value does not lie within a specified range, an error is generated. - * + * *

Multiple Option Names

- * + * * An option may be given several names, or aliases, in the form of a comma seperated list: - * + * * 
  * parser.addOption("-v,--verbose %v #print lots of info");
  * parser.addOption("-of,-outfile,-outputFile %s #output file");
  *
- * + * *

Single Word Options

- * + * * Normally, options are assumed to be "multi-word", meaning that any associated value must follow the option as a * separate argument string. For example, - * + * * 
  * parser.addOption("-file %s #file name");
  *
- * + * * will cause the parser to look for two strings in the argument list of the form - * + * * 
  *    -file someFileName
  *
- * + * * However, if there is no white space separting the option's name from it's conversion code, then values associated * with that option will be assumed to be part of the same argument string as the option itself. For example, - * + * * 
  * parser.addOption("-file=%s #file name");
  *
- * + * * will cause the parser to look for a single string in the argument list of the form - * + * * 
  *    -file=someFileName
  *
- * + * * Such an option is called a "single word" option. - * + * *

* In cases where an option has multiple names, then this single word behavior is invoked if there is no white space * between the last indicated name and the conversion code. However, previous names in the list will still be given * multi-word behavior if there is white space between the name and the following comma. For example, - * + * * 

  * parser.addOption("-nb=,-number ,-n%d #number of blocks");
  *
- * + * * will cause the parser to look for one, two, and one word constructions of the forms - * + * * 
  *    -nb=N
  *    -number N
  *    -nN
  *
- * + * *

Multiple Option Values

- * + * * If may be useful for an option to be followed by several values. For instance, we might have an option * -velocity which should be followed by three numbers denoting the x, y, and z components of a velocity * vector. We can require multiple values for an option by placing a multiplier specification, of the form * XN, where N is an integer, after the conversion code (or range specification, if present). For example, - * + * * 
  * double[] pos = new double[3];
- * 
+ *
  * addOption("-position %fX3 #position of the object", pos);
  *
- * + * * will cause the parser to look for - * + * * 
  *    -position xx yy zz
  *
- * + * * in the argument list, where xx, yy, and zz are numbers. The values are stored * in the array pos. - * + * * Options requiring multiple values must use arrays to return their values, and cannot be used in single word format. - * + * *

Multiple Option Invocation

- * + * * Normally, if an option appears twice in the command list, the value associated with the second instance simply * overwrites the value associated with the first instance. - * + * * However, the application can instead arrange for the storage of all values associated with multiple option * invocation, by supplying a instance of java.util.Vector to serve as the value holder. Then every time * the option appears in the argument list, the parser will create a value holder of appropriate type, set it to the * current value, and store the holder in the vector. For example, the construction - * + * * 
  * Vector vec = new Vector(10);
- * 
+ *
  * parser.addOption("-foo %f", vec);
  * parser.matchAllArgs(args);
  *
- * + * * when supplied with an argument list that contains - * + * * 
  *    -foo 1.2 -foo 1000 -foo -78
  *
- * + * * will create three instances of {@link argparser.DoubleHolder DoubleHolder}, initialized to 1.2, * 1000, and -78, and store them in vec. - * + * *

Generating help information

- * + * * ArgParser automatically generates help information for the options, and this information may be printed in response * to a help option, or may be queried by the application using {@link #getHelpMessage getHelpMessage}. The * information for each option consists of the option's name(s), it's required value(s), and an application-supplied @@ -258,55 +258,55 @@ import java.util.Vector; * specifications (although this can be overriden, as described below). The application-supplied * description is whatever appears in the specification string after the optional # character. The string * returned by {@link #getHelpMessage getHelpMessage} for the first example above would be - * + * * 
  * Usage: java argparser.SimpleExample
  * Options include:
- * 
+ *
  * -help,-?                displays help information
  * -theta <float>          theta value (in degrees)
  * -file <string>          name of the operating file
  * -debug                  enables display of debugging info
  *
- * + * * The options -help and -? are including in the parser by default as help options, and they * automatically cause the help message to be printed. To exclude these options, one should use the constructor * {@link #ArgParser(String,boolean) * ArgParser(synopsis,false)}. Help options can also be specified by the application using {@link #addOption addOption} * and the conversion code %h. Help options can be disabled using {@link #setHelpOptionsEnabled * setHelpOptionsEnabled(false)}. - * + * *

* A description of the required values for an option can be specified explicitly by placing a second * # character in the specification string. Everything between the first and second # * characters then becomes the value description, and everything after the second # character becomes the * option description. For example, if the -theta option above was specified with - * + * * 

  * parser.addOption("-theta %f #NUMBER#theta value (in degrees)", theta);
  *
- * + * * instead of - * + * * 
  * parser.addOption("-theta %f #theta value (in degrees)", theta);
  *
- * + * * then the corresponding entry in the help message would look like - * + * * 
  * -theta NUMBER          theta value (in degrees)
  *
- * + * *

Custom Argument Parsing

- * + * * An application may find it necessary to handle arguments that don't fit into the framework of this class. There are a * couple of ways to do this. - * + * *

* First, the method {@link #matchAllArgs(String[],int,int) * matchAllArgs(args,idx,exitFlags)} returns an array of all unmatched arguments, which can then be handled specially: - * + * * 

  *    String[] unmatched =
  *       parser.matchAllArgs (args, 0, parser.EXIT_ON_ERROR);
@@ -314,13 +314,13 @@ import java.util.Vector;
  *     { ... handle unmatched arguments ...
  *     }
  *
- * + * * For instance, this would be useful for an applicatoon that accepts an arbitrary number of input file names. The * options can be parsed using matchAllArgs, and the remaining unmatched arguments give the file names. - * + * *

* If we need more control over the parsing, we can parse arguments one at a time using {@link #matchArg matchArg}: - * + * * 

  *    int idx = 0;
  *    while (idx < args.length)
@@ -331,34 +331,34 @@ import java.util.Vector;
  *             ... handle this unmatched argument ourselves ...
  *           }
  *        }
- *       catch (ArgParserException e) 
+ *       catch (ArgParserException e)
  *        { // malformed or erroneous argument
  *          parser.printErrorAndExit (e.getMessage());
  *        }
  *     }
  *
- * + * * {@link #matchArg matchArg(args,idx)} matches one option at location idx in the argument list, and then * returns the location value that should be used for the next match. If an argument does not match any option, * {@link #getUnmatchedArgument getUnmatchedArgument} will return a copy of the unmatched argument. - * + * *

Reading Arguments From a File

- * + * * The method {@link #prependArgs prependArgs} can be used to automatically read in a set of arguments from a file and * prepend them onto an existing argument list. Argument words correspond to white-space-delimited strings, and the file * may contain the comment character # (which comments out everything to the end of the current line). A * typical usage looks like this: - * + * * 
  *    ... create parser and add options ...
- * 
+ *
  *    args = parser.prependArgs (new File(".configFile"), args);
- * 
+ *
  *    parser.matchAllArgs (args);
  *
- * + * * This makes it easy to generate simple configuration files for an application. - * + * * @author John E. Lloyd, Fall 2004 */ public class ArgParser { @@ -391,7 +391,7 @@ public class ArgParser { * Returns a string containing the valid conversion codes. These * are the characters which may follow the % character in * the specification string of {@link #addOption addOption}. - * + * * @return Valid conversion codes * @see #addOption */ @@ -891,7 +891,7 @@ public class ArgParser { /** * Creates an ArgParser with a synopsis * string, and the default help options -help and -?. - * + * * @param synopsisString string that briefly describes program usage, * for use by {@link #getHelpMessage getHelpMessage}. * @see ArgParser#getSynopsisString @@ -904,7 +904,7 @@ public class ArgParser { /** * Creates an ArgParser with a synopsis * string. The help options -help and -? are added if defaultHelp is true. - * + * * @param synopsisString string that briefly describes program usage, * for use by {@link #getHelpMessage getHelpMessage}. * @param defaultHelp if true, adds the default help options @@ -926,10 +926,10 @@ public class ArgParser { * the program, and usually looks something like *

* "java somepackage.SomeClass [options] files ..." - * + * *

* It is used in help and error messages. - * + * * @return synopsis string * @see ArgParser#setSynopsisString * @see ArgParser#getHelpMessage @@ -940,7 +940,7 @@ public class ArgParser { /** * Sets the synopsis string used by the parser. - * + * * @param s new synopsis string * @see ArgParser#getSynopsisString * @see ArgParser#getHelpMessage @@ -951,7 +951,7 @@ public class ArgParser { /** * Indicates whether or not help options are enabled. - * + * * @return true if help options are enabled * @see ArgParser#setHelpOptionsEnabled * @see ArgParser#addOption @@ -968,7 +968,7 @@ public class ArgParser { * program * exits with code 0. Otherwise, arguments which match help * options are ignored. - * + * * @param enable enables help options if true. * @see ArgParser#getHelpOptionsEnabled * @see ArgParser#addOption @@ -981,7 +981,7 @@ public class ArgParser { /** * Returns the default print stream used for outputting help * and error information. - * + * * @return default print stream * @see ArgParser#setDefaultPrintStream */ @@ -992,7 +992,7 @@ public class ArgParser { /** * Sets the default print stream used for outputting help * and error information. - * + * * @param stream new default print stream * @see ArgParser#getDefaultPrintStream */ @@ -1003,7 +1003,7 @@ public class ArgParser { /** * Gets the indentation used by {@link #getHelpMessage * getHelpMessage}. - * + * * @return number of indentation columns * @see ArgParser#setHelpIndentation * @see ArgParser#getHelpMessage @@ -1019,7 +1019,7 @@ public class ArgParser { * can fit within this number of columns, then all information about * the option is placed on one line. Otherwise, the indented help * information is placed on a separate line. - * + * * @param indent number of indentation columns * @see ArgParser#getHelpIndentation * @see ArgParser#getHelpMessage @@ -1119,25 +1119,25 @@ public class ArgParser { * Adds a new option description to the parser. The method takes two * arguments: a specification string, and a result holder in which to * store the associated value. - * + * *

* The specification string has the general form - * + * *

* optionNames %conversionCode [{rangeSpec}] * [Xmultiplier] [#valueDescription] [# * optionDescription] - * + * *

* where *

- * + * *

* The result holder must be an object capable of holding a value compatible with the conversion code, or it must be * a java.util.Vector. When the option is matched, its associated value is placed in the result holder. @@ -1226,78 +1226,78 @@ public class ArgParser { * is a java.util.Vector, in which case new holder objects for each match will be allocated and added * to the vector. Thus if multiple instances of an option are desired by the program, the result holder should be a * java.util.Vector. - * + * *

* If the result holder is not a Vector, then it must correspond as follows to the conversion code: - * + * * * * * * - * + * * * * * - * + * * * * * - * + * * * * * - * + * * * * * *
%i, %d, %x, %o{@link argparser.IntHolder IntHolder}, {@link argparser.LongHolder LongHolder}, int[], or * long[]
%f{@link argparser.FloatHolder FloatHolder}, {@link argparser.DoubleHolder DoubleHolder}, float[], * or double[]
%b, %v{@link argparser.BooleanHolder BooleanHolder} or boolean[]
%s{@link argparser.StringHolder StringHolder} or String[]
%c{@link argparser.CharHolder CharHolder} or char[]
- * + * *

* In addition, if the multiplier is greater than 1, then only the array type indicated above may be used, and the * array must be at least as long as the multiplier. - * + * *

* If the result holder is a Vector, then the system will create an appropriate * result holder object and add it to the vector. Multiple occurances of the option will cause multiple results to * be added to the vector. - * + * *

* The object allocated by the system to store the result will correspond to the conversion code as follows: - * + * * * * * * - * + * * * * * - * + * * * * * - * + * * * * * - * + * * * * * *
%i, %d, %x, %o{@link argparser.LongHolder LongHolder}, or long[] if the multiplier value exceeds 1
%f{@link argparser.DoubleHolder DoubleHolder}, or double[] if the multiplier value exceeds 1
%b, %v{@link argparser.BooleanHolder BooleanHolder}, or boolean[] if the multiplier value exceeds 1
%s{@link argparser.StringHolder StringHolder}, or String[] if the multiplier value exceeds 1
%c{@link argparser.CharHolder CharHolder}, or char[] if the multiplier value exceeds 1
- * + * * @param spec the specification string * @param resHolder object in which to store the associated * value @@ -1475,7 +1475,7 @@ public class ArgParser { rec.vval = rec.rangeList.low.bval; } } - // check for value multiplicity information, if any + // check for value multiplicity information, if any if (scanner.peekc() == 'X') { if (rec.convertCode == 'h') { throw new IllegalArgumentException("Multipliers not supported for %h"); @@ -1537,7 +1537,7 @@ public class ArgParser { } // parse helpMsg for required/optional information if present - // default to required + // default to required if (rec.helpMsg.indexOf("(optional") != -1) { rec.required = false; } @@ -1672,7 +1672,7 @@ public class ArgParser { * double quotes ". The character # acts as * a comment character, causing input to the end of the current line to * be ignored. - * + * * @param reader Reader from which to read the strings * @param args Initial set of argument values. Can be * specified as null. @@ -1716,7 +1716,7 @@ public class ArgParser { * quotes ". The character # acts as a * comment character, causing input to the end of the current line to * be ignored. - * + * * @param file File to be read * @param args Initial set of argument values. Can be * specified as null. @@ -1740,7 +1740,7 @@ public class ArgParser { /** * Sets the parser's error message. - * + * * @param s Error message */ protected void setError(String msg) { @@ -1763,17 +1763,17 @@ public class ArgParser { /** * Matches arguments within an argument list. - * + * *

* In the event of an erroneous or unmatched argument, the method prints a message and exits the program with code * 1. - * + * *

* If help options are enabled and one of the arguments matches a help option, then the result of * {@link #getHelpMessage * getHelpMessage} is printed to the default print stream and the program exits with code 0. If help options are not * enabled, they are ignored. - * + * * @param args argument list * @see ArgParser#getDefaultPrintStream */ @@ -1786,23 +1786,23 @@ public class ArgParser { * those which were not matched. The matching starts at a location * in args specified by idx, and * unmatched arguments are returned in a String array. - * + * *

* In the event of an erroneous argument, the method either prints a message and exits the program (if * {@link #EXIT_ON_ERROR} is set in exitFlags) or terminates the matching and creates a error message * that can be retrieved by {@link #getErrorMessage}. - * + * *

* In the event of an umatched argument, the method will print a message and exit if {@link #EXIT_ON_UNMATCHED} is * set in errorFlags. Otherwise, the unmatched argument will be appended to the returned array of * unmatched values, and the matching will continue at the next location. - * + * *

* If help options are enabled and one of the arguments matches a help option, then the result of * {@link #getHelpMessage * getHelpMessage} is printed to the the default print stream and the program exits with code 0. If help options are * not enabled, then they will not be matched. - * + * * @param args argument list * @param idx starting location in list * @param exitFlags conditions causing the program to exit. Should be @@ -1842,22 +1842,22 @@ public class ArgParser { * Matches one option starting at a specified location in an argument * list. The method returns the location in the list where the next * match should begin. - * + * *

* In the event of an erroneous argument, the method throws an {@link argparser.ArgParseException ArgParseException} * with an appropriate error message. This error message can also be retrieved using {@link #getErrorMessage * getErrorMessage}. - * + * *

* In the event of an umatched argument, the method will return idx + 1, and {@link #getUnmatchedArgument * getUnmatchedArgument} will return a copy of the unmatched argument. If an argument is matched, * {@link #getUnmatchedArgument getUnmatchedArgument} will return null. - * + * *

* If help options are enabled and the argument matches a help option, then the result of {@link #getHelpMessage * getHelpMessage} is printed to the the default print stream and the program exits with code 0. If help options are * not enabled, then they are ignored. - * + * * @param args argument list * @param idx location in list where match should start * @return location in list where next match should start @@ -1945,7 +1945,7 @@ public class ArgParser { // int col = initialIndent; // if (maxcols <= 0) - // { maxcols = 80; + // { maxcols = 80; // } // if (matchList.size() > 0) // { ps.print (spaceString(initialIndent)); @@ -1964,7 +1964,7 @@ public class ArgParser { // } // if (rec.convertCode != 'v' && rec.convertCode != 'h') // { if (rec.valueDesc != null) - // { s += rec.valueDesc; + // { s += rec.valueDesc; // } // else // { s = s + "<" + rec.valTypeName() + ">"; @@ -1974,13 +1974,13 @@ public class ArgParser { // } // } // s = s + "]"; - // /* - // (col+=s.length()) > (maxcols-1) => we will spill over edge. + // /* + // (col+=s.length()) > (maxcols-1) => we will spill over edge. // we use (maxcols-1) because if we go right to the edge // (maxcols), we get wrap new line inserted "for us". // i != 0 means we print the first entry, no matter // how long it is. Subsequent entries are printed - // full length anyway. */ + // full length anyway. */ // if ((col+=s.length()) > (maxcols-1) && i != 0) // { col = initialIndent+s.length(); @@ -1997,7 +1997,7 @@ public class ArgParser { /** * Returns a string describing the allowed options * in detail. - * + * * @return help information string. */ public String getHelpMessage() { @@ -2065,7 +2065,7 @@ public class ArgParser { * Returns the parser's error message. This is automatically * set whenever an error is encountered in matchArg or matchAllArgs, and is automatically * set to null at the beginning of these methods. - * + * * @return error message */ public String getErrorMessage() { @@ -2076,7 +2076,7 @@ public class ArgParser { * Returns the value of an unmatched argument discovered {@link #matchArg matchArg} or * {@link #matchAllArgs(String[],int,int) * matchAllArgs}. If there was no unmatched argument, null is returned. - * + * * @return unmatched argument */ public String getUnmatchedArgument() { -- cgit