Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.3 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.4
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.3	Wed Nov 28 17:21:09 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Wed Nov 28 20:02:12 2007
@@ -78,68 +78,73 @@
         }
     }
 
-    public static OptionKeyFactory getKeyFactory() {
-        if (keyFactory == null) {
-            keyFactory = new OptionKeyFactory();
-        }
-        return keyFactory;
-    }
-
     final org.apache.commons.logging.Log log;
 
-    /**
-     * le context du parseur : contient tous les index nécessaires pendant le
-     * parsing.
-     */
+    /** le context du parseur (contenant les données temporaires du parsing). */
     protected final ParserContext context;
 
-    protected final InitialContext initialContext;
+    /** la liste des définitions d'options connues */
+    protected final Map<String, OptionDefinition> definitions;
 
-    protected static OptionKeyFactory keyFactory;
+    /**
+     * la liste des options, la cle est le nom de l'option, et la valeur
+     * est la liste des options qui ont été lues grâce à celle-ci.
+     */
+    protected final HashMap<String, List<Option>> options;
+
+    /**
+     * La liste des arguments qui ne sont pas des options insérés dans leur
+     * ordre d'apparition dans la ligne de commande
+     */
+    protected final List<String> arguments;
 
     public OptionParser() {
 
         // find the fullyQualifiedFactoryName via OptionParserA annotation
         OptionParserA def = getClass().getAnnotation(OptionParserA.class);
         if (def == null) {
-            //TODO
-            throw new IllegalArgumentException("could not found annotation " + OptionParserA.class + " in Parser " + this);
+            //TODO  i18n
+            throw new IllegalArgumentException("could not found annotation " +
+                    OptionParserA.class + " in Parser " + this);
         }
         log = LogFactory.getLog(getClass());
 
-        getKeyFactory();
 
+        this.definitions = new LinkedHashMap<String, OptionDefinition>();
+        this.arguments = new ArrayList<String>();
+        this.options = new HashMap<String, List<Option>>();
         try {
-            Map<OptionKeyFactory.OptionKey, OptionDefinition> map;
+            Map<String, OptionDefinition> map;
             OptionDefinitionA defA;
             OptionDefinition definition;
 
-            map = new HashMap<OptionKeyFactory.OptionKey, OptionDefinition>();
+            map = new HashMap<String, OptionDefinition>();
 
             for (String key : def.keys()) {
                 String fieldName = StringUtil.convertToConstantName(key);
                 Field field = getClass().getField(fieldName);
-                OptionKeyFactory.OptionKey optionKey = (OptionKeyFactory.OptionKey) field.get(this);
-
                 defA = field.getAnnotation(OptionDefinitionA.class);
                 definition = new OptionDefinition(defA);
-                map.put(optionKey, definition);
+                map.put(key, definition);
             }
-            
-            initialContext = new InitialContext(map);
+            List<String> keys1 = new ArrayList<String>(map.keySet());
+            Collections.sort(keys1);
+            for (String key : keys1) {
+                this.definitions.put(key, map.get(key));
+            }
+            keys1.clear();
+            map.clear();
 
             // create parser context
-            context = new ParserContext();
-            
+            context = new ParserContext(this.definitions);
+
         } catch (NoSuchFieldException e) {
             throw new IllegalArgumentException(e);
-        } catch (IllegalAccessException e) {
-            throw new IllegalArgumentException(e);
         }
 
     }
 
-    public OptionParser doParse(String... args) throws OptionParserException {
+    public void doParse(String... args) throws OptionParserException {
         if (args.length > 0) {
             // detect OptionContexts
             prepareContexts(args);
@@ -157,38 +162,36 @@
         //TODO Report errors from context before clear context
 
         context.clear();
-
-        // return parser
-        return this;
     }
 
-    public boolean isEnabled(OptionKeyFactory.OptionKey key) {
-        List<Option> list = context.options.get(key);
+    public boolean isEnabled(String key) {
+        List<Option> list = options.get(key);
         return list != null && !list.isEmpty();
     }
 
-    public Option[] getOptions(OptionKeyFactory.OptionKey key) {
-        List<Option> list = context.options.get(key);
+    public Option[] getOptions(String key) {
+        List<Option> list = options.get(key);
         return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
     }
 
 
     public void printUsage(Writer writer, String name) throws IOException {
         writer.append(_("lutinutil.parserdef.printUsage.factory.head", name));
-        for (OptionKeyFactory.OptionKey key : initialContext.keys) {
-            initialContext.getDefinition(key).printUsage(writer);
+
+        for (OptionDefinition definition : definitions.values()) {
+            definition.printUsage(writer);
         }
     }
 
     public void printDetails(Writer writer) throws IOException {
-        int size = initialContext.keys.length;
+        int size = definitions.size();
         writer.append(_("lutinutil.parserdef.printDetail.factory.head",
                 this, size));
-        for (int i = 0; i < size; i++) {
-            OptionDefinition definition = initialContext.getDefinition(initialContext.keys[i]);
-            writer.append(_(LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD,
-                    i + 1, size, definition));
+        int i = 0;
+        for (OptionDefinition definition : definitions.values()) {
+            writer.append(_(LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD, i + 1, size, definition));
             definition.printDetail(writer);
+            i++;
         }
     }
 
@@ -208,12 +211,10 @@
             String argument = args[i];
             if (argument.startsWith("-")) {
                 // alias detected
-                OptionDefinition newOption = initialContext.indexAlias.get(argument);
+                OptionDefinition newOption = context.indexAlias.get(argument);
                 if (newOption == null) {
-                    // unknown option
-                    context.arguments.add(argument);
-                    //TODO This is a fatal error, no ?
-                    //throw new OptionParserException();
+                    // unknown argument
+                    arguments.add(argument);
                     continue;
                 }
                 // close the current optionContexts and add it to result
@@ -225,7 +226,7 @@
             }
             if (optionContext == null || !optionContext.addArgument(context, argument, i)) {
                 // no option opened or argument not accepted
-                context.arguments.add(argument);
+                arguments.add(argument);
             }
         }
 
@@ -242,15 +243,16 @@
      * arguments sont valides.
      * <p/>
      *
-     * @param context le contexte d'une option parsée
+     * @param optionContext le contexte d'une option parsée
      */
-    protected void instanciateOption(OptionContext context) {
+    protected void instanciateOption(OptionContext optionContext) {
 
         int position = 0;
 
         List<OptionArgument> arguments = new ArrayList<OptionArgument>();
 
-        for (OptionArgumentContext argumentContext : context.argumentsFound) {
+        for (OptionArgumentContext argumentContext : optionContext.argumentsFound) {
+
             // get argument from command line
             String argument = argumentContext.getArgument();
 
@@ -264,7 +266,19 @@
             Object value = ConvertUtils.convert(valueStr, argumentDefinition.getValueType().getClazz());
 
             // add argument to option
-            OptionArgument optionArgument = addOptionArgument(position, argumentContext, value);
+            OptionArgument optionArgument;
+
+            // get real position for this argument (-1 for an optional one)
+            int realPosition = argumentContext.definition.isMandatory() ? position : OptionArgumentDefinition.OPTIONAL_POSITION;
+
+            // instanciate concrete argument
+            optionArgument = new OptionArgument<Object>(
+                    argumentContext.definition,
+                    realPosition,
+                    argumentContext.argument,
+                    value
+            );
+
             arguments.add(optionArgument);
 
             if (argumentDefinition.isMandatory()) {
@@ -273,7 +287,21 @@
             }
         }
         // finally instanciate option and store it
-        addOption(context, arguments);
+        Option option;
+
+        String key = optionContext.definition.getName();
+
+        if (arguments.isEmpty()) {
+            option = new Option(optionContext.alias);
+        } else {
+            option = new Option(optionContext.alias,
+                    arguments.toArray(new OptionArgument[arguments.size()]));
+        }
+        List<Option> list = options.get(key);
+        if (list == null) {
+            options.put(key, list = new ArrayList<Option>());
+        }
+        list.add(option);
     }
 
 
@@ -290,7 +318,7 @@
             list.add(optionContext);
         }
 
-        for (OptionDefinition definition : initialContext.definitions.values()) {
+        for (OptionDefinition definition : definitions.values()) {
             List<OptionContext> contextList = map.get(definition);
             int min = definition.getMin();
             int max = definition.getMax();
@@ -337,89 +365,6 @@
         }
     }
 
-    protected void addOption(OptionContext optionContext, List<OptionArgument> arguments) {
-        Option option;
-
-        OptionKeyFactory.OptionKey key = optionContext.optionKey;
-        OptionDefinition definition = optionContext.definition;
-
-        if (arguments.isEmpty()) {
-            option = new Option(key, definition, optionContext.alias);
-        } else {
-            option = new Option(key, definition, optionContext.alias,
-                    arguments.toArray(new OptionArgument[arguments.size()]));
-        }
-        List<Option> list = context.options.get(key);
-        if (list == null) {
-            context.options.put(key, list = new ArrayList<Option>());
-        }
-        list.add(option);
-        context.parsedOptions.add(option);
-    }
-
-    protected OptionArgument addOptionArgument(int position, OptionArgumentContext conte,
-                                               Object value) {
-        // get unique argument key
-        //OptionKeyFactory.OptionArgumentKey argumentKey = keyFactory.getArgumentKey(definition);
-
-        // get real position for this argument (-1 for an optional one)
-        int realPosition = conte.definition.isMandatory() ? position : OptionArgumentDefinition.OPTIONAL_POSITION;
-
-        // instanciate concrete argument
-        OptionArgument optionArgument;
-        optionArgument = new OptionArgument<Object>(conte.argumentKey, conte.definition, realPosition, conte.argument, value);
-
-        // on sauvegarde l'argument dans l'option
-        //arguments.add(optionArgument);
-        return optionArgument;
-    }
-
-    /**
-     * Cette classe contient les index utilisés pendant le parsing.
-     * <p/>
-     * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
-     *
-     * @author chemit
-     */
-    protected class InitialContext {
-
-        /** la liste des définitions d'options connues */
-        protected final Map<OptionKeyFactory.OptionKey, OptionDefinition> definitions;
-
-
-        /** la liste des clefs d'option disponibles dans la factory */
-        protected final OptionKeyFactory.OptionKey[] keys;
-
-        /** la liste des définitions connues indexées par chacun de leurs alias */
-        protected final Map<String, OptionDefinition> indexAlias;
-
-        InitialContext(Map<OptionKeyFactory.OptionKey, OptionDefinition> map) {
-            List<OptionKeyFactory.OptionKey> keys1 = new ArrayList<OptionKeyFactory.OptionKey>(map.keySet());
-            Collections.sort(keys1);
-            this.indexAlias = new TreeMap<String, OptionDefinition>();
-            this.definitions = new LinkedHashMap<OptionKeyFactory.OptionKey, OptionDefinition>();
-            this.keys = keys1.toArray(new OptionKeyFactory.OptionKey[keys1.size()]);
-            for (OptionKeyFactory.OptionKey key : keys) {
-                this.definitions.put(key, map.get(key));
-            }
-            // build indexAlias
-            for (OptionDefinition optionDefinition : definitions.values()) {
-                for (String alias : optionDefinition.getAlias()) {
-                    indexAlias.put(alias, optionDefinition);
-                }
-            }
-        }
-
-        public OptionDefinition getDefinition(OptionKeyFactory.OptionKey key) {
-            return definitions.get(key);
-        }
-
-        public void clear() {
-            indexAlias.clear();
-            definitions.clear();
-        }
-    }
-
     /**
      * Cette classe contient les index utilisés pendant le parsing.
      * <p/>
@@ -429,15 +374,6 @@
      */
     class ParserContext {
 
-        /**
-         * la liste des options, la cle est le nom de l'option, et la valeur
-         * est la liste des options qui ont été lues grâce à celle-ci.
-         */
-        protected final HashMap<OptionKeyFactory.OptionKey, List<Option>> options;
-
-        /** liste a plat de toutes les options lus. */
-        protected final List<Option> parsedOptions;
-
         /** liste des définitions arguments obligatoires par position obligatoire */
         protected final Map<OptionDefinition, OptionArgumentDefinition[][]> mandatories;
 
@@ -447,19 +383,20 @@
         /** la liste des contextes d'options détectés */
         protected final List<OptionContext> optionContexts;
 
-        /**
-         * La liste des arguments qui ne sont pas des options insérés dans leur
-         * ordre d'apparition dans la ligne de commande
-         */
-        protected final List<String> arguments;
+        /** la liste des définitions connues indexées par chacun de leurs alias */
+        protected final Map<String, OptionDefinition> indexAlias;
 
-        ParserContext() {
+        ParserContext(Map<String, OptionDefinition> map) {
             this.mandatories = new HashMap<OptionDefinition, OptionArgumentDefinition[][]>();
             this.optionals = new HashMap<OptionDefinition, OptionArgumentDefinition[]>();
             this.optionContexts = new ArrayList<OptionContext>();
-            this.arguments = new ArrayList<String>();
-            this.options = new HashMap<OptionKeyFactory.OptionKey, List<Option>>();
-            this.parsedOptions = new ArrayList<Option>();
+            this.indexAlias = new TreeMap<String, OptionDefinition>();
+            // build indexAlias
+            for (OptionDefinition optionDefinition : map.values()) {
+                for (String alias : optionDefinition.getAlias()) {
+                    indexAlias.put(alias, optionDefinition);
+                }
+            }
         }
 
         void addOptionContext(OptionContext context) {
@@ -534,6 +471,7 @@
             mandatories.clear();
             optionals.clear();
             optionContexts.clear();
+            indexAlias.clear();
         }
     }
 
@@ -562,10 +500,8 @@
         /** la position obligatoire courante */
         protected int mandatoryPosition;
 
-        protected final OptionKeyFactory.OptionKey optionKey;
 
         OptionContext(OptionDefinition definition, String alias, int commandLinePosition) {
-            this.optionKey = getKeyFactory().getOptionKey(definition.getName());
             this.definition = definition;
             this.alias = alias;
             this.commandLinePosition = commandLinePosition;
@@ -587,9 +523,9 @@
 
             // find a matching argument definition
             if (argumentDefinition != null) {
-                OptionKeyFactory.OptionArgumentKey argumentKey = getKeyFactory().getArgumentKey(argumentDefinition);
+
                 OptionArgumentContext argumentContext;
-                argumentContext = new OptionArgumentContext(argumentKey, argumentDefinition, argument, position);
+                argumentContext = new OptionArgumentContext(argumentDefinition, argument, position);
 
                 argumentsFound.add(argumentContext);
                 //TODO Should test if argument is max* or max+
@@ -702,19 +638,12 @@
     protected final String argument;
 
     protected final int commandLinePosition;
-    protected final OptionKeyFactory.OptionArgumentKey argumentKey;
 
-    public OptionArgumentContext(OptionKeyFactory.OptionArgumentKey argumentKey,
-                                 OptionArgumentDefinition definition,
+    public OptionArgumentContext(OptionArgumentDefinition definition,
                                  String argument, int commandLinePosition) {
         this.argument = argument;
         this.commandLinePosition = commandLinePosition;
         this.definition = definition;
-        this.argumentKey = argumentKey;
-    }
-
-    public OptionKeyFactory.OptionArgumentKey getArgumentKey() {
-        return argumentKey;
     }
 
     public String getArgument() {

Index: lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.4 lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.5
--- lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java:1.4	Wed Nov 28 01:26:23 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinitionParser.java	Wed Nov 28 20:02:12 2007
@@ -24,9 +24,9 @@
 * Created: 22 août 2003
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.4 $
+* @version $Revision: 1.5 $
 *
-* Mise a jour: $Date: 2007-11-28 01:26:23 $
+* Mise a jour: $Date: 2007-11-28 20:02:12 $
 * par : $Author: tchemit $
 */
 
@@ -316,12 +316,8 @@
 
         // construction de la définition complête de l'option
         return safe ? new OptionDefinition(
-                definitionName,
-                description,
-                definition,
-                min,
-                max,
-                alias,
+                definitionName,description,definition,
+                min,max,alias,
                 argumentDefinitions.toArray(new OptionArgumentDefinition[argumentDefinitions.size()])
         ) : new SyntaxUnvalidOptionDefinition(description, definition);
     }
@@ -452,7 +448,7 @@
                     (Integer) typeAndMinAndMax[2],
                     position
             );
-            // register le new argument definition
+            // register the new argument definition
             definitionsFound.add(definition);
         }
         return result;
@@ -741,8 +737,8 @@
      */
     protected static class SyntaxUnvalidOptionDefinition extends OptionDefinition {
 
-        public SyntaxUnvalidOptionDefinition(String description, String definition) {
-            super(null, description, definition, 0, 0, 0, null);
+        private SyntaxUnvalidOptionDefinition(String description, String definition) {
+            super(null, description, definition, 0, 0, null, null);
         }
     }