Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.2 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.3
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.2	Wed Nov 28 01:30:34 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Wed Nov 28 17:21:09 2007
@@ -24,13 +24,17 @@
 import org.apache.commons.logging.LogFactory;
 import static org.codelutin.i18n.I18n._;
 import static org.codelutin.util.OptionDefinitionParser.LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionDefinitionA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionParserA;
 
 import java.io.IOException;
 import java.io.Writer;
+import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
@@ -39,10 +43,8 @@
  * Parser abstrait d'options de la ligne de commande.
  * <p/>
  * Pour implanter le parseur il suffit de surcharger cette classe et d'y ajouter
- * l'annotation {@link OptionParserAnnotation} au niveau de la classe, en y
- * indiquant la définition du parser (pour le moment uniquement le nom
- * complet de l'usine de définitions d'options
- * {@link OptionParserAnnotation#factoryName()}).
+ * l'annotation {@link OptionParserAnnotationHelper.OptionParserA} au niveau de la classe, en y
+ * indiquant la définition du parser.
  * <p/>
  * Ensuite on utilise la méthode publique statique {@link #newParser(String, ClassLoader)}
  * pour obtenir une nouvelle instance de parser à partir du nom de sa classe et
@@ -52,30 +54,11 @@
  * pour effectuer le parsing des arguments passés.
  *
  * @author chemit
- * @see OptionParserAnnotation
+ * @see OptionParserAnnotationHelper.OptionParserA
  */
 
 public abstract class OptionParser {
 
-    /**
-     * Annotation pour définir le paramètrage d'un parseur d'option
-     *
-     * @author chemit
-     */
-    @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
-
-    @java.lang.annotation.Target(value = java.lang.annotation.ElementType.TYPE)
-
-    public static @interface OptionParserAnnotation {
-
-        /** @return le nom de l'usine de définitions d'options utilisée */
-        public String factoryName();
-
-        /** @return la liste des clef d'options disponibles */
-        public String[] keys();
-
-    }
-
     public static OptionParser newParser(String className, ClassLoader loader) {
 
         Class parserClass;
@@ -95,7 +78,14 @@
         }
     }
 
-    static org.apache.commons.logging.Log log = LogFactory.getLog(OptionParser.class);
+    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
@@ -103,28 +93,50 @@
      */
     protected final ParserContext context;
 
+    protected final InitialContext initialContext;
+
+    protected static OptionKeyFactory keyFactory;
+
     public OptionParser() {
 
-        // find the fullyQualifiedFactoryName via OptionParserAnnotation
-        // annotation
-        OptionParserAnnotation def = getClass().getAnnotation(OptionParserAnnotation.class);
+        // find the fullyQualifiedFactoryName via OptionParserA annotation
+        OptionParserA def = getClass().getAnnotation(OptionParserA.class);
         if (def == null) {
             //TODO
-            throw new IllegalArgumentException("could not found annotation " + OptionParserAnnotation.class + " in Parser " + this);
+            throw new IllegalArgumentException("could not found annotation " + OptionParserA.class + " in Parser " + this);
         }
+        log = LogFactory.getLog(getClass());
 
-        String fullyQualifiedFactoryName = def.factoryName();
+        getKeyFactory();
 
-        String[] keys = def.keys();
+        try {
+            Map<OptionKeyFactory.OptionKey, OptionDefinition> map;
+            OptionDefinitionA defA;
+            OptionDefinition definition;
+
+            map = new HashMap<OptionKeyFactory.OptionKey, 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);
+            }
+            
+            initialContext = new InitialContext(map);
+
+            // create parser context
+            context = new ParserContext();
+            
+        } catch (NoSuchFieldException e) {
+            throw new IllegalArgumentException(e);
+        } catch (IllegalAccessException e) {
+            throw new IllegalArgumentException(e);
+        }
 
-        // obtain instance of factory
-        OptionDefinitionFactory definitionFactory =
-                OptionDefinitionFactory.newFactory(
-                        fullyQualifiedFactoryName,
-                        getClass().getClassLoader()
-                );
-        // create parser context
-        context = new ParserContext(keys, definitionFactory.getDefinitions());
     }
 
     public OptionParser doParse(String... args) throws OptionParserException {
@@ -142,7 +154,7 @@
                 instanciateOption(optionContext);
             }
         }
-        //TODO Report errors from context before suppress context
+        //TODO Report errors from context before clear context
 
         context.clear();
 
@@ -150,40 +162,30 @@
         return this;
     }
 
-    public OptionKeyFactory.OptionKey[] getKeys() {
-        return context.keys;
-    }
-
-    public OptionKeyFactory.OptionKey getKey(String key) {
-        for (OptionKeyFactory.OptionKey optionKey : context.keys) {
-            if (optionKey.name().equals(key)) {
-                return optionKey;
-            }
-        }
-        return null;
+    public boolean isEnabled(OptionKeyFactory.OptionKey key) {
+        List<Option> list = context.options.get(key);
+        return list != null && !list.isEmpty();
     }
 
-    public OptionDefinition[] getDefinitions() {
-        return context.definitions;
+    public Option[] getOptions(OptionKeyFactory.OptionKey key) {
+        List<Option> list = context.options.get(key);
+        return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
     }
 
-    public OptionDefinition getDefinition(OptionKeyFactory.OptionKey key) {
-        return context.getDefinition(key);
-    }
 
     public void printUsage(Writer writer, String name) throws IOException {
         writer.append(_("lutinutil.parserdef.printUsage.factory.head", name));
-        for (OptionKeyFactory.OptionKey key : context.keys) {
-            context.getDefinition(key).printUsage(writer);
+        for (OptionKeyFactory.OptionKey key : initialContext.keys) {
+            initialContext.getDefinition(key).printUsage(writer);
         }
     }
 
     public void printDetails(Writer writer) throws IOException {
-        int size = context.keys.length;
+        int size = initialContext.keys.length;
         writer.append(_("lutinutil.parserdef.printDetail.factory.head",
                 this, size));
         for (int i = 0; i < size; i++) {
-            OptionDefinition definition = context.getDefinition(context.keys[i]);
+            OptionDefinition definition = initialContext.getDefinition(initialContext.keys[i]);
             writer.append(_(LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD,
                     i + 1, size, definition));
             definition.printDetail(writer);
@@ -206,7 +208,7 @@
             String argument = args[i];
             if (argument.startsWith("-")) {
                 // alias detected
-                OptionDefinition newOption = context.indexAlias.get(argument);
+                OptionDefinition newOption = initialContext.indexAlias.get(argument);
                 if (newOption == null) {
                     // unknown option
                     context.arguments.add(argument);
@@ -262,7 +264,8 @@
             Object value = ConvertUtils.convert(valueStr, argumentDefinition.getValueType().getClazz());
 
             // add argument to option
-            addOptionArgument(position, argument, argumentDefinition, value, arguments);
+            OptionArgument optionArgument = addOptionArgument(position, argumentContext, value);
+            arguments.add(optionArgument);
 
             if (argumentDefinition.isMandatory()) {
                 // increments next mandatory position
@@ -287,7 +290,7 @@
             list.add(optionContext);
         }
 
-        for (OptionDefinition definition : context.definitions) {
+        for (OptionDefinition definition : initialContext.definitions.values()) {
             List<OptionContext> contextList = map.get(definition);
             int min = definition.getMin();
             int max = definition.getMax();
@@ -336,19 +339,16 @@
 
     protected void addOption(OptionContext optionContext, List<OptionArgument> arguments) {
         Option option;
-        OptionKeyFactory.OptionKey key;
 
+        OptionKeyFactory.OptionKey key = optionContext.optionKey;
         OptionDefinition definition = optionContext.definition;
 
-        key = OptionKeyFactory.getOptionKey(definition.getName());
-
         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>());
@@ -357,355 +357,372 @@
         context.parsedOptions.add(option);
     }
 
-    protected void addOptionArgument(int position, String argument,
-                                     OptionArgumentDefinition definition,
-                                     Object value, List<OptionArgument> arguments) {
+    protected OptionArgument addOptionArgument(int position, OptionArgumentContext conte,
+                                               Object value) {
         // get unique argument key
-        OptionKeyFactory.OptionArgumentKey argumentKey = OptionKeyFactory.getArgumentKey(definition);
+        //OptionKeyFactory.OptionArgumentKey argumentKey = keyFactory.getArgumentKey(definition);
 
         // get real position for this argument (-1 for an optional one)
-        int realPosition = definition.isMandatory() ? position : OptionArgumentDefinition.OPTIONAL_POSITION;
+        int realPosition = conte.definition.isMandatory() ? position : OptionArgumentDefinition.OPTIONAL_POSITION;
 
         // instanciate concrete argument
-        OptionArgument optionArgument = new OptionArgument<Object>(argumentKey, realPosition, argument, value);
+        OptionArgument optionArgument;
+        optionArgument = new OptionArgument<Object>(conte.argumentKey, conte.definition, realPosition, conte.argument, value);
 
         // on sauvegarde l'argument dans l'option
-        arguments.add(optionArgument);
+        //arguments.add(optionArgument);
+        return optionArgument;
     }
 
-    protected OptionKeyFactory.OptionKey registerKey(String key) {
-        OptionKeyFactory.OptionKey result = OptionKeyFactory.getOptionKey(key);
-        log.info(key + " : " + result);
-        //context.keys.add(result);
-        //Collections.sort(context.keys);
-        return result;
-    }
-
-}
-
-/**
- * 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
- */
-class ParserContext {
-
-    /** la liste des définitions d'options connues */
-    protected final OptionDefinition[] definitions;
-
     /**
-     * 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.
+     * 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 final HashMap<OptionKeyFactory.OptionKey, List<Option>> options;
+    protected class InitialContext {
 
-    /** liste a plat de toutes les options lus. */
-    protected final List<Option> parsedOptions;
+        /** 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 clefs d'option disponibles dans la factory */
+        protected final OptionKeyFactory.OptionKey[] keys;
 
-    /** liste des définitions arguments obligatoires par position obligatoire */
-    protected final Map<OptionDefinition, OptionArgumentDefinition[][]> mandatories;
-
-    /** la liste des définitions d'arguments optionnels */
-    protected final Map<OptionDefinition, OptionArgumentDefinition[]> optionals;
+        /** 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);
+                }
+            }
+        }
 
-    /** la liste des définitions connues indexées par chacun de leurs alias */
-    protected final Map<String, OptionDefinition> indexAlias;
+        public OptionDefinition getDefinition(OptionKeyFactory.OptionKey key) {
+            return definitions.get(key);
+        }
 
-    /** la liste des contextes d'options détectés */
-    protected final List<OptionContext> optionContexts;
+        public void clear() {
+            indexAlias.clear();
+            definitions.clear();
+        }
+    }
 
     /**
-     * La liste des arguments qui ne sont pas des options insérés dans leur
-     * ordre d'apparition dans la ligne de commande
+     * 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 final List<String> arguments;
+    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;
 
-    ParserContext(String[] keys, OptionDefinition[] definitions) {
-        mandatories = new HashMap<OptionDefinition, OptionArgumentDefinition[][]>();
-        optionals = new HashMap<OptionDefinition, OptionArgumentDefinition[]>();
-        optionContexts = new ArrayList<OptionContext>();
-        indexAlias = new TreeMap<String, OptionDefinition>();
-        // build indexAlias
-        for (OptionDefinition optionDefinition : definitions) {
-            for (String alias : optionDefinition.getAlias()) {
-                indexAlias.put(alias, optionDefinition);
-            }
-        }
-        this.definitions = definitions;
-        this.arguments = new ArrayList<String>();
-        this.options = new HashMap<OptionKeyFactory.OptionKey, List<Option>>();
-        this.parsedOptions = new ArrayList<Option>();
-        ArrayList<OptionKeyFactory.OptionKey> tmp = new ArrayList<OptionKeyFactory.OptionKey>();
-        for (String key : keys) {
-            OptionKeyFactory.OptionKey optionKey = OptionKeyFactory.getOptionKey(key);
-            tmp.add(optionKey);
-            OptionParser.log.info(_("lutinutil.parserdef.field.info",optionKey.toString(),this.toString()));
-        }
-        Collections.sort(tmp);
-        this.keys = tmp.toArray(new OptionKeyFactory.OptionKey[tmp.size()]);
+        /** 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;
 
-    void addOptionContext(OptionContext context) {
-        if (context != null) {
-            optionContexts.add(context);
-        }
-    }
+        /** la liste des définitions d'arguments optionnels */
+        protected final Map<OptionDefinition, OptionArgumentDefinition[]> optionals;
 
-    OptionArgumentDefinition[] getMandatories(OptionDefinition definition, int mandatoryPosition) {
-        OptionArgumentDefinition[][] result = mandatories.get(definition);
-        if (result == null) {
-            build(definition);
-            result = mandatories.get(definition);
-        }
-        if (mandatoryPosition >= result.length) {
-            return new OptionArgumentDefinition[0];
-        }
-        return result[mandatoryPosition];
-    }
+        /** la liste des contextes d'options détectés */
+        protected final List<OptionContext> optionContexts;
 
-    int getMaxMandatories(OptionDefinition definition) {
-        OptionArgumentDefinition[][] result = mandatories.get(definition);
-        if (result == null) {
-            build(definition);
-            result = mandatories.get(definition);
-        }
-        return result.length;
-    }
+        /**
+         * 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;
 
-    OptionArgumentDefinition[] getOptionals(OptionDefinition definition) {
-        OptionArgumentDefinition[] result = optionals.get(definition);
-        if (result == null) {
-            build(definition);
-            result = optionals.get(definition);
+        ParserContext() {
+            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>();
         }
-        return result;
-    }
 
-    private void build(OptionDefinition definition) {
-        // build for this option definition
-        // construit les tables d'arguments optionels et obligatoires
-        List<OptionArgumentDefinition> _optionals = new ArrayList<OptionArgumentDefinition>();
-        List<Collection<OptionArgumentDefinition>> _mandatories = new ArrayList<Collection<OptionArgumentDefinition>>();
-        OptionArgumentDefinition[] argumentDefinitions = definition.getArguments();
-        int size = argumentDefinitions.length;
-        for (int i = 0; i < size; i++) {
-            _mandatories.add(new ArrayList<OptionArgumentDefinition>());
-        }
-        for (OptionArgumentDefinition argument : argumentDefinitions) {
-            if (argument.getPosition() == -1) {
-                _optionals.add(argument);
-                continue;
+        void addOptionContext(OptionContext context) {
+            if (context != null) {
+                optionContexts.add(context);
             }
-            int pos = argument.getPosition();
-            Collection<OptionArgumentDefinition> list = _mandatories.get(pos);
-            list.add(argument);
-        }
-        this.optionals.put(definition, _optionals.toArray(new OptionArgumentDefinition[_optionals.size()]));
-        _optionals.clear();
-        int mandatoriesLength = _mandatories.size();
-        OptionArgumentDefinition[][] result;
-        result = new OptionArgumentDefinition[mandatoriesLength][];
-        for (int i = 0; i < mandatoriesLength; i++) {
-            Collection<OptionArgumentDefinition> _argumentDefinitions = _mandatories.get(i);
-            result[i] = _argumentDefinitions.toArray(new OptionArgumentDefinition[_argumentDefinitions.size()]);
         }
-        this.mandatories.put(definition, result);
-        _mandatories.clear();
-    }
-
-    public void clear() {
-        mandatories.clear();
-        optionals.clear();
-        indexAlias.clear();
-        optionContexts.clear();
-    }
 
-    public OptionDefinition getDefinition(OptionKeyFactory.OptionKey key) {
-        for (OptionDefinition definition : definitions) {
-            if (definition.getName().equals(key.name)) {
-                return definition;
+        OptionArgumentDefinition[] getMandatories(OptionDefinition definition, int mandatoryPosition) {
+            OptionArgumentDefinition[][] result = mandatories.get(definition);
+            if (result == null) {
+                build(definition);
+                result = mandatories.get(definition);
+            }
+            if (mandatoryPosition >= result.length) {
+                return new OptionArgumentDefinition[0];
             }
+            return result[mandatoryPosition];
         }
-        return null;
-    }
-}
 
-/**
- * Cette classe contient un argument d'option récupéré pendant le parsing.
- * <p/>
- * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
- *
- * @author chemit
- */
-class OptionArgumentContext {
-
-    protected final OptionArgumentDefinition definition;
-
-    protected final String argument;
-
-    protected final int commandLinePosition;
+        int getMaxMandatories(OptionDefinition definition) {
+            OptionArgumentDefinition[][] result = mandatories.get(definition);
+            if (result == null) {
+                build(definition);
+                result = mandatories.get(definition);
+            }
+            return result.length;
+        }
 
-    public OptionArgumentContext(OptionArgumentDefinition definition,
-                                 String argument, int commandLinePosition) {
-        this.argument = argument;
-        this.commandLinePosition = commandLinePosition;
-        this.definition = definition;
-    }
+        OptionArgumentDefinition[] getOptionals(OptionDefinition definition) {
+            OptionArgumentDefinition[] result = optionals.get(definition);
+            if (result == null) {
+                build(definition);
+                result = optionals.get(definition);
+            }
+            return result;
+        }
 
-    public String getArgument() {
-        return argument;
+        private void build(OptionDefinition definition) {
+            // build for this option definition
+            // construit les tables d'arguments optionels et obligatoires
+            List<OptionArgumentDefinition> _optionals = new ArrayList<OptionArgumentDefinition>();
+            List<Collection<OptionArgumentDefinition>> _mandatories = new ArrayList<Collection<OptionArgumentDefinition>>();
+            OptionArgumentDefinition[] argumentDefinitions = definition.getArguments();
+            int size = argumentDefinitions.length;
+            for (int i = 0; i < size; i++) {
+                _mandatories.add(new ArrayList<OptionArgumentDefinition>());
+            }
+            for (OptionArgumentDefinition argument : argumentDefinitions) {
+                if (argument.getPos() == -1) {
+                    _optionals.add(argument);
+                    continue;
+                }
+                int pos = argument.getPos();
+                Collection<OptionArgumentDefinition> list = _mandatories.get(pos);
+                list.add(argument);
+            }
+            this.optionals.put(definition, _optionals.toArray(new OptionArgumentDefinition[_optionals.size()]));
+            _optionals.clear();
+            int mandatoriesLength = _mandatories.size();
+            OptionArgumentDefinition[][] result;
+            result = new OptionArgumentDefinition[mandatoriesLength][];
+            for (int i = 0; i < mandatoriesLength; i++) {
+                Collection<OptionArgumentDefinition> _argumentDefinitions = _mandatories.get(i);
+                result[i] = _argumentDefinitions.toArray(new OptionArgumentDefinition[_argumentDefinitions.size()]);
+            }
+            this.mandatories.put(definition, result);
+            _mandatories.clear();
+        }
+
+        public void clear() {
+            mandatories.clear();
+            optionals.clear();
+            optionContexts.clear();
+        }
     }
 
-    public OptionArgumentDefinition getDefinition() {
-        return definition;
-    }
-}
+    /**
+     * Cette classe contient une option et ses arguments récupérés avant le
+     * parsing de l'option.
+     * <p/>
+     * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
+     *
+     * @author chemit
+     */
+    class OptionContext {
 
-/**
- * Cette classe contient une option et ses arguments récupérés avant le
- * parsing de l'option.
- * <p/>
- * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
- *
- * @author chemit
- */
-class OptionContext {
+        /** definition of option */
+        protected final OptionDefinition definition;
 
-    /** definition of option */
-    protected final OptionDefinition definition;
+        /** alias used for this option */
+        protected final String alias;
 
-    /** alias used for this option */
-    protected final String alias;
+        /** the position of this option in the command line */
+        protected final int commandLinePosition;
+
+        /** la liste des context d'arguments trouvés */
+        protected final List<OptionArgumentContext> argumentsFound;
+
+        /** 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;
+            this.argumentsFound = new ArrayList<OptionArgumentContext>();
+            this.mandatoryPosition = 0;
+        }
+
+        /**
+         * Tente d'ajouter un argument à l'option du context.
+         *
+         * @param parserContext le context de parser
+         * @param argument      l'argument à ajouter
+         * @param position      la position de l'argument dans la ligne de commande
+         * @return <code>true</code> si l'argument a été ajouté à l'option,<code>false</code> autrement.
+         */
+        boolean addArgument(OptionParser.ParserContext parserContext, String argument, int position) {
+
+            OptionArgumentDefinition argumentDefinition = findArgument(parserContext, argument);
+
+            // find a matching argument definition
+            if (argumentDefinition != null) {
+                OptionKeyFactory.OptionArgumentKey argumentKey = getKeyFactory().getArgumentKey(argumentDefinition);
+                OptionArgumentContext argumentContext;
+                argumentContext = new OptionArgumentContext(argumentKey, argumentDefinition, argument, position);
+
+                argumentsFound.add(argumentContext);
+                //TODO Should test if argument is max* or max+
+                //TODO and change only if argument position is != from current
+                if (argumentDefinition.isMandatory()) {
+                    // was a mandatory argument increments mandatoryPosition
+                    mandatoryPosition++;
+                }
+            }
 
-    /** the position of this option in the command line */
-    protected final int commandLinePosition;
+            return argumentDefinition != null;
+        }
 
-    /** la liste des context d'arguments trouvés */
-    protected final List<OptionArgumentContext> argumentsFound;
+        OptionArgumentDefinition findArgument(OptionParser.ParserContext parserContext, String argument) {
 
-    /** la position obligatoire courante */
-    protected int mandatoryPosition;
+            OptionArgumentDefinition result = null;
 
-    OptionContext(OptionDefinition definition, String alias, int commandLinePosition) {
-        this.definition = definition;
-        this.alias = alias;
-        this.commandLinePosition = commandLinePosition;
-        this.argumentsFound = new ArrayList<OptionArgumentContext>();
-        this.mandatoryPosition = 0;
-    }
+            OptionArgumentDefinition[] defs = parserContext.getMandatories(definition, mandatoryPosition);
 
-    /**
-     * Tente d'ajouter un argument à l'option du context.
-     *
-     * @param parserContext le context de parser
-     * @param argument      l'argument à ajouter
-     * @param position      la position de l'argument dans la ligne de commande
-     * @return <code>true</code> si l'argument a été ajouté à l'option,<code>false</code> autrement.
-     */
-    boolean addArgument(ParserContext parserContext, String argument, int position) {
+            OptionArgumentDefinition[] optionals = parserContext.getOptionals(definition);
+            boolean named = argument.indexOf('=') > -1;
 
-        OptionArgumentDefinition argumentDefinition = findArgument(parserContext, argument);
+            if (optionals.length > 0) {
+                result = findArgument0(named, argument, optionals);
+            }
 
-        // find a matching argument definition
-        if (argumentDefinition != null) {
+            if (result == null && defs.length > 0) {
+                result = findArgument0(named, argument, defs);
+            }
+            log.info("[" + argument + "] :" + result);
+            return result;
+        }
 
-            OptionArgumentContext argumentContext = new OptionArgumentContext(argumentDefinition, argument, position);
+        private OptionArgumentDefinition findArgument0(boolean named, String argument, OptionArgumentDefinition[] defs) {
+            OptionArgumentType type;
+            OptionArgumentDefinition result;
+            if (named) {
+                String key = argument.substring(0, argument.indexOf('='));
+                type = OptionArgumentType.namedAndValued;
 
-            argumentsFound.add(argumentContext);
+                // find in a optional first
+                result = findArgumentByTypeAndKey(type, key, defs);
 
-            if (argumentDefinition.getPosition() > -1) {
-                // was a mandatory argument increments mandatoryPosition
-                mandatoryPosition++;
+                return result;
             }
-        }
 
-        return argumentDefinition != null;
-    }
+            type = OptionArgumentType.constant;
 
-    OptionArgumentDefinition findArgument(ParserContext parserContext, String argument) {
-
-        OptionArgumentDefinition result;
+            // find in a constant optional
+            result = findArgumentByTypeAndKey(type, argument, defs);
+            if (result != null) {
+                return result;
+            }
 
-        OptionArgumentType type;
 
-        OptionArgumentDefinition[] defs = parserContext.getMandatories(definition, mandatoryPosition);
+            type = OptionArgumentType.valued;
 
-        OptionArgumentDefinition[] optionals = parserContext.getOptionals(definition);
+            OptionArgumentValueType valueType;
 
-        if (argument.indexOf('=') > -1) {
-            String key = argument.substring(0, argument.indexOf('='));
-            type = OptionArgumentType.namedAndValued;
+            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
 
-            // find in a optional first
-            result = findArgumentByTypeAndKey(type, key, optionals);
-            if (result == null) {
-                // find a mandatory option
-                result = findArgumentByTypeAndKey(type, key, defs);
+            // find a valued optinal
+            result = findArgumentByTypeAndValueType(type, valueType, defs);
+            if (result != null) {
+                return result;
+            }
+            if (valueType == OptionArgumentValueType._newfile) {
+                // we didn't find a _newFile, it could be also a string
+                result = findArgumentByTypeAndValueType(type, OptionArgumentValueType._string, defs);
             }
             return result;
         }
 
-        type = OptionArgumentType.constant;
-
-        // find in a constant optional
-        result = findArgumentByTypeAndKey(type, argument, optionals);
-        if (result != null) {
-            return result;
+        OptionArgumentDefinition findArgumentByTypeAndKey(OptionArgumentType type,
+                                                          String key,
+                                                          OptionArgumentDefinition... defs) {
+            for (OptionArgumentDefinition argumentDefinion : defs) {
+                if (argumentDefinion.getType() == type && argumentDefinion.getKey().equals(key)) {
+                    return argumentDefinion;
+                }
+            }
+            return null;
         }
 
-        // find a constant mandatory option
-        result = findArgumentByTypeAndKey(type, argument, defs);
-        if (result != null) {
-            return result;
+        OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type,
+                                                                OptionArgumentValueType valueType,
+                                                                OptionArgumentDefinition... defs) {
+            for (OptionArgumentDefinition argumentDefinion : defs) {
+                if (argumentDefinion.getType() == type && argumentDefinion.getValueType() == valueType) {
+                    return argumentDefinion;
+                }
+            }
+            return null;
         }
+    }
+}
 
-        type = OptionArgumentType.valued;
 
-        OptionArgumentValueType valueType;
+/**
+ * Cette classe contient un argument d'option récupéré pendant le parsing.
+ * <p/>
+ * Elle est de visibilité package, car elle n'a pas à être utilisée ailleurs.
+ *
+ * @author chemit
+ */
+class OptionArgumentContext {
+
+    protected final OptionArgumentDefinition definition;
 
-        valueType = OptionArgumentValueType.findTypeFromArgument(argument);
+    protected final String argument;
 
-        // find a valued optinal
-        result = findArgumentByTypeAndValueType(type, valueType, optionals);
-        if (result != null) {
-            return result;
-        }
+    protected final int commandLinePosition;
+    protected final OptionKeyFactory.OptionArgumentKey argumentKey;
 
-        // find a valued mandatory option
-        if (result == null) {
-            result = findArgumentByTypeAndValueType(type, valueType, defs);
-        }
+    public OptionArgumentContext(OptionKeyFactory.OptionArgumentKey argumentKey,
+                                 OptionArgumentDefinition definition,
+                                 String argument, int commandLinePosition) {
+        this.argument = argument;
+        this.commandLinePosition = commandLinePosition;
+        this.definition = definition;
+        this.argumentKey = argumentKey;
+    }
 
-        return result;
+    public OptionKeyFactory.OptionArgumentKey getArgumentKey() {
+        return argumentKey;
     }
 
-    OptionArgumentDefinition findArgumentByTypeAndKey(OptionArgumentType type,
-                                                      String key,
-                                                      OptionArgumentDefinition... defs) {
-        for (OptionArgumentDefinition argumentDefinion : defs) {
-            if (argumentDefinion.getType() == type && argumentDefinion.getKey().equals(key)) {
-                return argumentDefinion;
-            }
-        }
-        return null;
+    public String getArgument() {
+        return argument;
     }
 
-    OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type,
-                                                            OptionArgumentValueType valueType,
-                                                            OptionArgumentDefinition... defs) {
-        for (OptionArgumentDefinition argumentDefinion : defs) {
-            if (argumentDefinion.getType() == type && argumentDefinion.getValueType() == valueType) {
-                return argumentDefinion;
-            }
-        }
-        return null;
+    public OptionArgumentDefinition getDefinition() {
+        return definition;
     }
-}
\ No newline at end of file
+}
+