Minor syntax changes

ebourg · ebourg · commit 3936da9d3fe3 · 2012-10-30T17:24:20.000Z
git-svn-id: https://svn.apache.org/repos/asf/commons/proper/cli/trunk@1403792 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/src/main/java/org/apache/commons/cli/GnuParser.java b/src/main/java/org/apache/commons/cli/GnuParser.java
@@ -49,7 +49,7 @@ public class GnuParser extends Parser
      */
     protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)
     {
-        List tokens = new ArrayList();
+        List<String> tokens = new ArrayList<String>();
 
         boolean eatTheRest = false;
 
@@ -109,6 +109,6 @@ else if (options.hasOption(arg.substring(0, 2)))
             }
         }
 
-        return (String[]) tokens.toArray(new String[tokens.size()]);
+        return tokens.toArray(new String[tokens.size()]);
     }
 }
diff --git a/src/main/java/org/apache/commons/cli/HelpFormatter.java b/src/main/java/org/apache/commons/cli/HelpFormatter.java
@@ -577,10 +577,10 @@ public void printUsage(PrintWriter pw, int width, String app, Options options)
             Collections.sort(optList, getOptionComparator());
         }
         // iterate over the options
-        for (Iterator i = optList.iterator(); i.hasNext();)
+        for (Iterator<Option> it = optList.iterator(); it.hasNext();)
         {
             // get the next Option
-            Option option = (Option) i.next();
+            Option option = it.next();
 
             // check if the option is part of an OptionGroup
             OptionGroup group = options.getOptionGroup(option);
@@ -609,7 +609,7 @@ public void printUsage(PrintWriter pw, int width, String app, Options options)
                 appendOption(buff, option, option.isRequired());
             }
 
-            if (i.hasNext())
+            if (it.hasNext())
             {
                 buff.append(" ");
             }
@@ -641,12 +641,12 @@ private void appendOptionGroup(StringBuffer buff, OptionGroup group)
             Collections.sort(optList, getOptionComparator());
         }
         // for each option in the OptionGroup
-        for (Iterator i = optList.iterator(); i.hasNext();)
+        for (Iterator<Option> it = optList.iterator(); it.hasNext();)
         {
             // whether the option is required or not is handled at group level
-            appendOption(buff, (Option) i.next(), true);
+            appendOption(buff, it.next(), true);
 
-            if (i.hasNext())
+            if (it.hasNext())
             {
                 buff.append(" | ");
             }
@@ -833,9 +833,9 @@ protected StringBuffer renderOptions(StringBuffer sb, int width, Options options
 
         int x = 0;
 
-        for (Iterator i = optList.iterator(); i.hasNext();)
+        for (Iterator<Option> it = optList.iterator(); it.hasNext();)
         {
-            Option option = (Option) i.next();
+            Option option = it.next();
             StringBuilder optBuf = new StringBuilder(prefixList.get(x++).toString());
 
             if (optBuf.length() < max)
@@ -854,7 +854,7 @@ protected StringBuffer renderOptions(StringBuffer sb, int width, Options options
 
             renderWrappedText(sb, width, nextLineTabStop, optBuf.toString());
 
-            if (i.hasNext())
+            if (it.hasNext())
             {
                 sb.append(getNewLine());
             }
diff --git a/src/main/java/org/apache/commons/cli/Parser.java b/src/main/java/org/apache/commons/cli/Parser.java
@@ -20,7 +20,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
-import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Properties;
@@ -140,20 +139,15 @@ public CommandLine parse(Options options, String[] arguments, boolean stopAtNonO
      *
      * @since 1.1
      */
-    public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption)
-            throws ParseException
+    public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption) throws ParseException
     {
         // clear out the data in options in case it's been used before (CLI-71)
-        for (Iterator it = options.helpOptions().iterator(); it.hasNext();)
-        {
-            Option opt = (Option) it.next();
+        for (Option opt : options.helpOptions()) {
             opt.clearValues();
         }
         
         // clear the data from the groups
-        for (Iterator it = options.getOptionGroups().iterator(); it.hasNext();)
-        {
-            OptionGroup group = (OptionGroup) it.next();
+        for (OptionGroup group : options.getOptionGroups()) {
             group.setSelected(null);
         }        
 
@@ -169,14 +163,14 @@ public CommandLine parse(Options options, String[] arguments, Properties propert
             arguments = new String[0];
         }
 
-        List tokenList = Arrays.asList(flatten(getOptions(), arguments, stopAtNonOption));
+        List<String> tokenList = Arrays.asList(flatten(getOptions(), arguments, stopAtNonOption));
 
-        ListIterator iterator = tokenList.listIterator();
+        ListIterator<String> iterator = tokenList.listIterator();
 
         // process each flattened token
         while (iterator.hasNext())
         {
-            String t = (String) iterator.next();
+            String t = iterator.next();
 
             // the value is the double-dash
             if ("--".equals(t))
@@ -227,7 +221,7 @@ else if (t.startsWith("-"))
             {
                 while (iterator.hasNext())
                 {
-                    String str = (String) iterator.next();
+                    String str = iterator.next();
 
                     // ensure only one double-dash is added
                     if (!"--".equals(str))
@@ -308,8 +302,7 @@ else if (!("yes".equalsIgnoreCase(value)
      * Throws a {@link MissingOptionException} if all of the required options
      * are not present.
      *
-     * @throws MissingOptionException if any of the required Options
-     * are not present.
+     * @throws MissingOptionException if any of the required Options are not present.
      */
     protected void checkRequiredOptions() throws MissingOptionException
     {
@@ -321,24 +314,23 @@ protected void checkRequiredOptions() throws MissingOptionException
     }
 
     /**
-     * <p>Process the argument values for the specified Option
+     * Process the argument values for the specified Option
      * <code>opt</code> using the values retrieved from the
      * specified iterator <code>iter</code>.
      *
      * @param opt The current Option
-     * @param iter The iterator over the flattened command line
-     * Options.
+     * @param iter The iterator over the flattened command line Options.
      *
      * @throws ParseException if an argument value is required
      * and it is has not been found.
      */
-    public void processArgs(Option opt, ListIterator iter) throws ParseException
+    public void processArgs(Option opt, ListIterator<String> iter) throws ParseException
     {
         // loop until an option is found
         while (iter.hasNext())
         {
-            String str = (String) iter.next();
-
+            String str = iter.next();
+            
             // found an Option, not an argument
             if (getOptions().hasOption(str) && str.startsWith("-"))
             {
@@ -373,7 +365,7 @@ public void processArgs(Option opt, ListIterator iter) throws ParseException
      *
      * @throws ParseException if <code>arg</code> does not represent an Option
      */
-    protected void processOption(String arg, ListIterator iter) throws ParseException
+    protected void processOption(String arg, ListIterator<String> iter) throws ParseException
     {
         boolean hasOption = getOptions().hasOption(arg);
 
@@ -384,7 +376,7 @@ protected void processOption(String arg, ListIterator iter) throws ParseExceptio
         }
 
         // get the option represented by arg
-        Option opt = (Option) getOptions().getOption(arg).clone();
+        Option opt = getOptions().getOption(arg).clone();
         
         // update the required options and groups
         updateRequiredOptions(opt);
diff --git a/src/main/java/org/apache/commons/cli/PosixParser.java b/src/main/java/org/apache/commons/cli/PosixParser.java
@@ -33,7 +33,7 @@
 public class PosixParser extends Parser
 {
     /** holder for flattened tokens */
-    private List tokens = new ArrayList();
+    private List<String> tokens = new ArrayList<String>();
 
     /** specifies if bursting should continue */
     private boolean eatTheRest;
@@ -99,13 +99,13 @@ protected String[] flatten(Options options, String[] arguments, boolean stopAtNo
         this.options = options;
 
         // an iterator for the command line tokens
-        Iterator iter = Arrays.asList(arguments).iterator();
+        Iterator<String> iter = Arrays.asList(arguments).iterator();
 
         // process each command line token
         while (iter.hasNext())
         {
             // get the next command line token
-            String token = (String) iter.next();
+            String token = iter.next();
 
             // single or double hyphen
             if ("-".equals(token) || "--".equals(token))
@@ -119,7 +119,7 @@ else if (token.startsWith("--"))
                 int pos = token.indexOf('=');
                 String opt = pos == -1 ? token : token.substring(0, pos); // --foo
                 
-                List matchingOpts = options.getMatchingOptions(opt);
+                List<String> matchingOpts = options.getMatchingOptions(opt);
 
                 if (matchingOpts.isEmpty())
                 {
@@ -131,7 +131,7 @@ else if (matchingOpts.size() > 1)
                 }
                 else
                 {
-                    currentOption = options.getOption((String) matchingOpts.get(0));
+                    currentOption = options.getOption(matchingOpts.get(0));
                     
                     tokens.add("--" + currentOption.getLongOpt());
                     if (pos != -1)
@@ -149,14 +149,14 @@ else if (token.startsWith("-"))
                 }
                 else if (!options.getMatchingOptions(token).isEmpty())
                 {
-                    List matchingOpts = options.getMatchingOptions(token);
+                    List<String> matchingOpts = options.getMatchingOptions(token);
                     if (matchingOpts.size() > 1)
                     {
                         throw new AmbiguousOptionException(token, matchingOpts);
                     }
                     else
                     {
-                        Option opt = options.getOption((String) matchingOpts.get(0));
+                        Option opt = options.getOption(matchingOpts.get(0));
                         processOptionToken("-" + opt.getLongOpt(), stopAtNonOption);
                     }
                 }
@@ -174,15 +174,15 @@ else if (!options.getMatchingOptions(token).isEmpty())
             gobble(iter);
         }
 
-        return (String[]) tokens.toArray(new String[tokens.size()]);
+        return tokens.toArray(new String[tokens.size()]);
     }
 
     /**
      * Adds the remaining tokens to the processed tokens list.
      *
      * @param iter An iterator over the remaining tokens
      */
-    private void gobble(Iterator iter)
+    private void gobble(Iterator<String> iter)
     {
         if (eatTheRest)
         {
diff --git a/src/main/java/org/apache/commons/cli/TypeHandler.java b/src/main/java/org/apache/commons/cli/TypeHandler.java
@@ -110,7 +110,7 @@ else if (PatternOptionBuilder.URL_VALUE == clazz)
       */
     public static Object createObject(String classname) throws ParseException
     {
-        Class cl = null;
+        Class cl;
 
         try
         {
@@ -120,19 +120,15 @@ public static Object createObject(String classname) throws ParseException
         {
             throw new ParseException("Unable to find the class: " + classname);
         }
-
-        Object instance = null;
-
+        
         try
         {
-            instance = cl.newInstance();
+            return cl.newInstance();
         }
         catch (Exception e)
         {
             throw new ParseException(e.getClass().getName() + "; Unable to create an instance of: " + classname);
         }
-
-        return instance;
     }
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public class GnuParser extends Parser`
`49`	`49`	`*/`
`50`	`50`	`protected String[] flatten(Options options, String[] arguments, boolean stopAtNonOption)`
`51`	`51`	`{`
`52`		`- List tokens = new ArrayList();`
	`52`	`+ List<String> tokens = new ArrayList<String>();`
`53`	`53`
`54`	`54`	`boolean eatTheRest = false;`
`55`	`55`
`@@ -109,6 +109,6 @@ else if (options.hasOption(arg.substring(0, 2)))`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`
`112`		`- return (String[]) tokens.toArray(new String[tokens.size()]);`
	`112`	`+ return tokens.toArray(new String[tokens.size()]);`
`113`	`113`	`}`
`114`	`114`	`}`
Original file line number	Diff line number	Diff line change
`@@ -577,10 +577,10 @@ public void printUsage(PrintWriter pw, int width, String app, Options options)`
`577`	`577`	`Collections.sort(optList, getOptionComparator());`
`578`	`578`	`}`
`579`	`579`	`// iterate over the options`
`580`		`- for (Iterator i = optList.iterator(); i.hasNext();)`
	`580`	`+ for (Iterator<Option> it = optList.iterator(); it.hasNext();)`
`581`	`581`	`{`
`582`	`582`	`// get the next Option`
`583`		`- Option option = (Option) i.next();`
	`583`	`+ Option option = it.next();`
`584`	`584`
`585`	`585`	`// check if the option is part of an OptionGroup`
`586`	`586`	`OptionGroup group = options.getOptionGroup(option);`
`@@ -609,7 +609,7 @@ public void printUsage(PrintWriter pw, int width, String app, Options options)`
`609`	`609`	`appendOption(buff, option, option.isRequired());`
`610`	`610`	`}`
`611`	`611`
`612`		`- if (i.hasNext())`
	`612`	`+ if (it.hasNext())`
`613`	`613`	`{`
`614`	`614`	`buff.append(" ");`
`615`	`615`	`}`
`@@ -641,12 +641,12 @@ private void appendOptionGroup(StringBuffer buff, OptionGroup group)`
`641`	`641`	`Collections.sort(optList, getOptionComparator());`
`642`	`642`	`}`
`643`	`643`	`// for each option in the OptionGroup`
`644`		`- for (Iterator i = optList.iterator(); i.hasNext();)`
	`644`	`+ for (Iterator<Option> it = optList.iterator(); it.hasNext();)`
`645`	`645`	`{`
`646`	`646`	`// whether the option is required or not is handled at group level`
`647`		`- appendOption(buff, (Option) i.next(), true);`
	`647`	`+ appendOption(buff, it.next(), true);`
`648`	`648`
`649`		`- if (i.hasNext())`
	`649`	`+ if (it.hasNext())`
`650`	`650`	`{`
`651`	`651`	`buff.append(" \| ");`
`652`	`652`	`}`
`@@ -833,9 +833,9 @@ protected StringBuffer renderOptions(StringBuffer sb, int width, Options options`
`833`	`833`
`834`	`834`	`int x = 0;`
`835`	`835`
`836`		`- for (Iterator i = optList.iterator(); i.hasNext();)`
	`836`	`+ for (Iterator<Option> it = optList.iterator(); it.hasNext();)`
`837`	`837`	`{`
`838`		`- Option option = (Option) i.next();`
	`838`	`+ Option option = it.next();`
`839`	`839`	`StringBuilder optBuf = new StringBuilder(prefixList.get(x++).toString());`
`840`	`840`
`841`	`841`	`if (optBuf.length() < max)`
`@@ -854,7 +854,7 @@ protected StringBuffer renderOptions(StringBuffer sb, int width, Options options`
`854`	`854`
`855`	`855`	`renderWrappedText(sb, width, nextLineTabStop, optBuf.toString());`
`856`	`856`
`857`		`- if (i.hasNext())`
	`857`	`+ if (it.hasNext())`
`858`	`858`	`{`
`859`	`859`	`sb.append(getNewLine());`
`860`	`860`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`import java.util.ArrayList;`
`21`	`21`	`import java.util.Arrays;`
`22`	`22`	`import java.util.Enumeration;`
`23`		`-import java.util.Iterator;`
`24`	`23`	`import java.util.List;`
`25`	`24`	`import java.util.ListIterator;`
`26`	`25`	`import java.util.Properties;`
`@@ -140,20 +139,15 @@ public CommandLine parse(Options options, String[] arguments, boolean stopAtNonO`
`140`	`139`	`*`
`141`	`140`	`* @since 1.1`
`142`	`141`	`*/`
`143`		`- public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption)`
`144`		`- throws ParseException`
	`142`	`+ public CommandLine parse(Options options, String[] arguments, Properties properties, boolean stopAtNonOption) throws ParseException`
`145`	`143`	`{`
`146`	`144`	`// clear out the data in options in case it's been used before (CLI-71)`
`147`		`- for (Iterator it = options.helpOptions().iterator(); it.hasNext();)`
`148`		`- {`
`149`		`- Option opt = (Option) it.next();`
	`145`	`+ for (Option opt : options.helpOptions()) {`
`150`	`146`	`opt.clearValues();`
`151`	`147`	`}`
`152`	`148`
`153`	`149`	`// clear the data from the groups`
`154`		`- for (Iterator it = options.getOptionGroups().iterator(); it.hasNext();)`
`155`		`- {`
`156`		`- OptionGroup group = (OptionGroup) it.next();`
	`150`	`+ for (OptionGroup group : options.getOptionGroups()) {`
`157`	`151`	`group.setSelected(null);`
`158`	`152`	`}`
`159`	`153`
`@@ -169,14 +163,14 @@ public CommandLine parse(Options options, String[] arguments, Properties propert`
`169`	`163`	`arguments = new String[0];`
`170`	`164`	`}`
`171`	`165`
`172`		`- List tokenList = Arrays.asList(flatten(getOptions(), arguments, stopAtNonOption));`
	`166`	`+ List<String> tokenList = Arrays.asList(flatten(getOptions(), arguments, stopAtNonOption));`
`173`	`167`
`174`		`- ListIterator iterator = tokenList.listIterator();`
	`168`	`+ ListIterator<String> iterator = tokenList.listIterator();`
`175`	`169`
`176`	`170`	`// process each flattened token`
`177`	`171`	`while (iterator.hasNext())`
`178`	`172`	`{`
`179`		`- String t = (String) iterator.next();`
	`173`	`+ String t = iterator.next();`
`180`	`174`
`181`	`175`	`// the value is the double-dash`
`182`	`176`	`if ("--".equals(t))`
`@@ -227,7 +221,7 @@ else if (t.startsWith("-"))`
`227`	`221`	`{`
`228`	`222`	`while (iterator.hasNext())`
`229`	`223`	`{`
`230`		`- String str = (String) iterator.next();`
	`224`	`+ String str = iterator.next();`
`231`	`225`
`232`	`226`	`// ensure only one double-dash is added`
`233`	`227`	`if (!"--".equals(str))`
`@@ -308,8 +302,7 @@ else if (!("yes".equalsIgnoreCase(value)`
`308`	`302`	`* Throws a {@link MissingOptionException} if all of the required options`
`309`	`303`	`* are not present.`
`310`	`304`	`*`
`311`		`- * @throws MissingOptionException if any of the required Options`
`312`		`- * are not present.`
	`305`	`+ * @throws MissingOptionException if any of the required Options are not present.`
`313`	`306`	`*/`
`314`	`307`	`protected void checkRequiredOptions() throws MissingOptionException`
`315`	`308`	`{`
`@@ -321,24 +314,23 @@ protected void checkRequiredOptions() throws MissingOptionException`
`321`	`314`	`}`
`322`	`315`
`323`	`316`	`/**`
`324`		`- * <p>Process the argument values for the specified Option`
	`317`	`+ * Process the argument values for the specified Option`
`325`	`318`	`* <code>opt</code> using the values retrieved from the`
`326`	`319`	`* specified iterator <code>iter</code>.`
`327`	`320`	`*`
`328`	`321`	`* @param opt The current Option`
`329`		`- * @param iter The iterator over the flattened command line`
`330`		`- * Options.`
	`322`	`+ * @param iter The iterator over the flattened command line Options.`
`331`	`323`	`*`
`332`	`324`	`* @throws ParseException if an argument value is required`
`333`	`325`	`* and it is has not been found.`
`334`	`326`	`*/`
`335`		`- public void processArgs(Option opt, ListIterator iter) throws ParseException`
	`327`	`+ public void processArgs(Option opt, ListIterator<String> iter) throws ParseException`
`336`	`328`	`{`
`337`	`329`	`// loop until an option is found`
`338`	`330`	`while (iter.hasNext())`
`339`	`331`	`{`
`340`		`- String str = (String) iter.next();`
`341`		`-`
	`332`	`+ String str = iter.next();`
	`333`	`+`
`342`	`334`	`// found an Option, not an argument`
`343`	`335`	`if (getOptions().hasOption(str) && str.startsWith("-"))`
`344`	`336`	`{`
`@@ -373,7 +365,7 @@ public void processArgs(Option opt, ListIterator iter) throws ParseException`
`373`	`365`	`*`
`374`	`366`	`* @throws ParseException if <code>arg</code> does not represent an Option`
`375`	`367`	`*/`
`376`		`- protected void processOption(String arg, ListIterator iter) throws ParseException`
	`368`	`+ protected void processOption(String arg, ListIterator<String> iter) throws ParseException`
`377`	`369`	`{`
`378`	`370`	`boolean hasOption = getOptions().hasOption(arg);`
`379`	`371`
`@@ -384,7 +376,7 @@ protected void processOption(String arg, ListIterator iter) throws ParseExceptio`
`384`	`376`	`}`
`385`	`377`
`386`	`378`	`// get the option represented by arg`
`387`		`- Option opt = (Option) getOptions().getOption(arg).clone();`
	`379`	`+ Option opt = getOptions().getOption(arg).clone();`
`388`	`380`
`389`	`381`	`// update the required options and groups`
`390`	`382`	`updateRequiredOptions(opt);`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@`
`33`	`33`	`public class PosixParser extends Parser`
`34`	`34`	`{`
`35`	`35`	`/** holder for flattened tokens */`
`36`		`- private List tokens = new ArrayList();`
	`36`	`+ private List<String> tokens = new ArrayList<String>();`
`37`	`37`
`38`	`38`	`/** specifies if bursting should continue */`
`39`	`39`	`private boolean eatTheRest;`
`@@ -99,13 +99,13 @@ protected String[] flatten(Options options, String[] arguments, boolean stopAtNo`
`99`	`99`	`this.options = options;`
`100`	`100`
`101`	`101`	`// an iterator for the command line tokens`
`102`		`- Iterator iter = Arrays.asList(arguments).iterator();`
	`102`	`+ Iterator<String> iter = Arrays.asList(arguments).iterator();`
`103`	`103`
`104`	`104`	`// process each command line token`
`105`	`105`	`while (iter.hasNext())`
`106`	`106`	`{`
`107`	`107`	`// get the next command line token`
`108`		`- String token = (String) iter.next();`
	`108`	`+ String token = iter.next();`
`109`	`109`
`110`	`110`	`// single or double hyphen`
`111`	`111`	`if ("-".equals(token) \|\| "--".equals(token))`
`@@ -119,7 +119,7 @@ else if (token.startsWith("--"))`
`119`	`119`	`int pos = token.indexOf('=');`
`120`	`120`	`String opt = pos == -1 ? token : token.substring(0, pos); // --foo`
`121`	`121`
`122`		`- List matchingOpts = options.getMatchingOptions(opt);`
	`122`	`+ List<String> matchingOpts = options.getMatchingOptions(opt);`
`123`	`123`
`124`	`124`	`if (matchingOpts.isEmpty())`
`125`	`125`	`{`
`@@ -131,7 +131,7 @@ else if (matchingOpts.size() > 1)`
`131`	`131`	`}`
`132`	`132`	`else`
`133`	`133`	`{`
`134`		`- currentOption = options.getOption((String) matchingOpts.get(0));`
	`134`	`+ currentOption = options.getOption(matchingOpts.get(0));`
`135`	`135`
`136`	`136`	`tokens.add("--" + currentOption.getLongOpt());`
`137`	`137`	`if (pos != -1)`
`@@ -149,14 +149,14 @@ else if (token.startsWith("-"))`
`149`	`149`	`}`
`150`	`150`	`else if (!options.getMatchingOptions(token).isEmpty())`
`151`	`151`	`{`
`152`		`- List matchingOpts = options.getMatchingOptions(token);`
	`152`	`+ List<String> matchingOpts = options.getMatchingOptions(token);`
`153`	`153`	`if (matchingOpts.size() > 1)`
`154`	`154`	`{`
`155`	`155`	`throw new AmbiguousOptionException(token, matchingOpts);`
`156`	`156`	`}`
`157`	`157`	`else`
`158`	`158`	`{`
`159`		`- Option opt = options.getOption((String) matchingOpts.get(0));`
	`159`	`+ Option opt = options.getOption(matchingOpts.get(0));`
`160`	`160`	`processOptionToken("-" + opt.getLongOpt(), stopAtNonOption);`
`161`	`161`	`}`
`162`	`162`	`}`
`@@ -174,15 +174,15 @@ else if (!options.getMatchingOptions(token).isEmpty())`
`174`	`174`	`gobble(iter);`
`175`	`175`	`}`
`176`	`176`
`177`		`- return (String[]) tokens.toArray(new String[tokens.size()]);`
	`177`	`+ return tokens.toArray(new String[tokens.size()]);`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`/**`
`181`	`181`	`* Adds the remaining tokens to the processed tokens list.`
`182`	`182`	`*`
`183`	`183`	`* @param iter An iterator over the remaining tokens`
`184`	`184`	`*/`
`185`		`- private void gobble(Iterator iter)`
	`185`	`+ private void gobble(Iterator<String> iter)`
`186`	`186`	`{`
`187`	`187`	`if (eatTheRest)`
`188`	`188`	`{`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ else if (PatternOptionBuilder.URL_VALUE == clazz)`
`110`	`110`	`*/`
`111`	`111`	`public static Object createObject(String classname) throws ParseException`
`112`	`112`	`{`
`113`		`- Class cl = null;`
	`113`	`+ Class cl;`
`114`	`114`
`115`	`115`	`try`
`116`	`116`	`{`
`@@ -120,19 +120,15 @@ public static Object createObject(String classname) throws ParseException`
`120`	`120`	`{`
`121`	`121`	`throw new ParseException("Unable to find the class: " + classname);`
`122`	`122`	`}`
`123`		`-`
`124`		`- Object instance = null;`
`125`		`-`
	`123`	`+`
`126`	`124`	`try`
`127`	`125`	`{`
`128`		`- instance = cl.newInstance();`
	`126`	`+ return cl.newInstance();`
`129`	`127`	`}`
`130`	`128`	`catch (Exception e)`
`131`	`129`	`{`
`132`	`130`	`throw new ParseException(e.getClass().getName() + "; Unable to create an instance of: " + classname);`
`133`	`131`	`}`
`134`		`-`
`135`		`- return instance;`
`136`	`132`	`}`
`137`	`133`
`138`	`134`	`/**`