Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.1 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.2
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.1	Mon Nov 19 20:50:12 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Wed Nov 28 01:30:34 2007
@@ -18,21 +18,12 @@
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *##%*/
 
-/* *
-* OptionParser.java
-*
-* Created: 22 août 2003
-*
-* @author Benjamin Poussin <poussin@codelutin.com>
-* @version $Revision: 1.1 $
-*
-* Mise a jour: $Date: 2007-11-19 20:50:12 $
-* par : $Author: tchemit $
-*/
-
 package org.codelutin.util;
 
 import org.apache.commons.beanutils.ConvertUtils;
+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 java.io.IOException;
 import java.io.Writer;
@@ -45,491 +36,676 @@
 import java.util.TreeMap;
 
 /**
- * Parser d'options de la ligne de commande.
+ * 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()}).
+ * <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
+ * de son classLoader.
+ * <p/>
+ * Enfin sur le parseur retourné, on invoque la méthode {@link #doParse(String[])}
+ * pour effectuer le parsing des arguments passés.
  *
- * @author poussin
  * @author chemit
+ * @see OptionParserAnnotation
  */
-public class OptionParser {
 
-    public static OptionParser doParse(String name,
-                                       String fullyQualifiedFactoryName,
-                                       String... args)
-            throws OptionParserException {
+public abstract class OptionParser {
 
-        OptionParser parser;
+    /**
+     * Annotation pour définir le paramètrage d'un parseur d'option
+     *
+     * @author chemit
+     */
+    @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
 
-        parser = new OptionParser(name);
+    @java.lang.annotation.Target(value = java.lang.annotation.ElementType.TYPE)
 
-        Map<String, OptionDefinition> indexAlias = parser.init(fullyQualifiedFactoryName);
-        List<OptionContext> contexts = null;
+    public static @interface OptionParserAnnotation {
 
-        if (args.length > 0) {
+        /** @return le nom de l'usine de définitions d'options utilisée */
+        public String factoryName();
 
-            // detection des contexts d'options
-            contexts = parser.detectOptionContexts(indexAlias, args);
+        /** @return la liste des clef d'options disponibles */
+        public String[] keys();
+
+    }
+
+    public static OptionParser newParser(String className, ClassLoader loader) {
+
+        Class parserClass;
+        OptionParser parser;
+        try {
+            // find parser class
+            parserClass = Class.forName(className, true, loader);
+            // instanciate parser, load factory and init ParserContext
+            parser = (OptionParser) parserClass.newInstance();
+            return parser;
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException(e);
+        } catch (IllegalAccessException e) {
+            throw new IllegalArgumentException(e);
+        } catch (InstantiationException e) {
+            throw new IllegalArgumentException(e);
         }
+    }
 
-        // verification de la coherence des options détectée par rapport aux
-        // definitions des options
-        parser.checkPostParsing(contexts);
+    static org.apache.commons.logging.Log log = LogFactory.getLog(OptionParser.class);
 
-        if (contexts != null && !contexts.isEmpty()) {
-            for (OptionContext context : contexts) {
-                parser.instanciateOption(context);
-            }
-            // on vide les contextes
-            contexts.clear();
+    /**
+     * le context du parseur : contient tous les index nécessaires pendant le
+     * parsing.
+     */
+    protected final ParserContext context;
+
+    public OptionParser() {
+
+        // find the fullyQualifiedFactoryName via OptionParserAnnotation
+        // annotation
+        OptionParserAnnotation def = getClass().getAnnotation(OptionParserAnnotation.class);
+        if (def == null) {
+            //TODO
+            throw new IllegalArgumentException("could not found annotation " + OptionParserAnnotation.class + " in Parser " + this);
         }
 
-        return parser;
+        String fullyQualifiedFactoryName = def.factoryName();
+
+        String[] keys = def.keys();
+
+        // 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 {
+        if (args.length > 0) {
+            // detect OptionContexts
+            prepareContexts(args);
+        }
 
-    /** l'usine de définitions d'options */
-    protected OptionDefinitionFactory definitionFactory;
+        // check coherence on detected OptionContexts TODO Finish me
+        checkPostParsing();
 
-    /** La liste des arguments qui ne sont pas des options */
-    protected List<String> arguments;
+        if (context.optionContexts != null) {
+            for (OptionContext optionContext : context.optionContexts) {
+                // instanciate option from his context
+                instanciateOption(optionContext);
+            }
+        }
+        //TODO Report errors from context before suppress context
 
-    /** le nom à afficher pour l'usage */
-    protected String name;
+        context.clear();
 
-    /**
-     * 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 Map<String, List<Option>> options;
+        // return parser
+        return this;
+    }
 
-    /** liste a plat de toutes les options lus. */
-    protected List<Option> parsedOptions;
+    public OptionKeyFactory.OptionKey[] getKeys() {
+        return context.keys;
+    }
 
-    protected OptionParser(String name) {
-        this.name = name;
-        this.options = new HashMap<String, List<Option>>();
-        this.parsedOptions = new ArrayList<Option>();
-        this.arguments = new ArrayList<String>();
+    public OptionKeyFactory.OptionKey getKey(String key) {
+        for (OptionKeyFactory.OptionKey optionKey : context.keys) {
+            if (optionKey.name().equals(key)) {
+                return optionKey;
+            }
+        }
+        return null;
     }
 
-    public void printUsage(Writer writer) {
-        try {
-            definitionFactory.printUsage(writer, this.name);
-        } catch (IOException e) {
-            // should never appear
-            throw new RuntimeException(e);
+    public OptionDefinition[] getDefinitions() {
+        return context.definitions;
+    }
+
+    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);
         }
     }
 
-    @SuppressWarnings({"unchecked"})
-    protected Map<String, OptionDefinition> init(String fullyQualifiedFactoryName) {
-        try {
-            // obtain instance of factory
-            definitionFactory = OptionDefinitionFactory.newFactory((Class<? extends OptionDefinitionFactory>) Class.forName(fullyQualifiedFactoryName));
-            // build indexAlias
-            Map<String, OptionDefinition> indexAlias = new TreeMap<String, OptionDefinition>();
-            for (OptionDefinition optionDefinition : definitionFactory.getOptions()) {
-                for (String alias : optionDefinition.getAlias()) {
-                    indexAlias.put(alias, optionDefinition);
-                }
-            }
-            return indexAlias;
-        } catch (InstantiationException e) {
-            throw new IllegalArgumentException(e);
-        } catch (IllegalAccessException e) {
-            throw new IllegalArgumentException(e);
-        } catch (ClassNotFoundException e) {
-            throw new IllegalArgumentException(e);
+    public void printDetails(Writer writer) throws IOException {
+        int size = context.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]);
+            writer.append(_(LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD,
+                    i + 1, size, definition));
+            definition.printDetail(writer);
         }
     }
 
     /**
      * Detecte les options et leurs arguments, à partir de la suite des
      * arguments donnés et construit la liste des context d'options.
+     * <p/>
+     * Prépare avec les contexts d'options.
      *
-     * @param indexAlias la talbe des alias disponibles
-     * @param args       la liste des arguments à scanner
-     * @return la liste des contextes d'option trouvée en parcourant toute la
-     *         liste des arguments donnés
+     * @param args la liste des arguments à scanner
      */
-    protected List<OptionContext> detectOptionContexts(Map<String, OptionDefinition>
-            indexAlias, String... args) {
-        List<OptionContext> result = new ArrayList<OptionContext>();
+    protected void prepareContexts(String... args) {
 
-        OptionContext context = null;
+        OptionContext optionContext = null;
 
         for (int i = 0; i < args.length; i++) {
             String argument = args[i];
             if (argument.startsWith("-")) {
-                // an alias detected
-                OptionDefinition newOption = indexAlias.get(argument);
+                // alias detected
+                OptionDefinition newOption = context.indexAlias.get(argument);
                 if (newOption == null) {
                     // unknown option
-                    arguments.add(argument);
+                    context.arguments.add(argument);
+                    //TODO This is a fatal error, no ?
+                    //throw new OptionParserException();
                     continue;
                 }
-                if (context != null) {
-                    // close the current context and add it to result
-                    result.add(context);
-                }
-                context = new OptionContext(newOption, argument, i);
+                // close the current optionContexts and add it to result
+                context.addOptionContext(optionContext);
+
+
+                optionContext = new OptionContext(newOption, argument, i);
                 continue;
             }
-            if (context == null || !context.addArgument(argument, i)) {
-                // no option opened or argumnet not accepted
-                arguments.add(argument);
+            if (optionContext == null || !optionContext.addArgument(context, argument, i)) {
+                // no option opened or argument not accepted
+                context.arguments.add(argument);
             }
         }
 
-        if (context != null) {
-            // close the current context and add it to result
-            result.add(context);
-        }
+        // close the current optionContexts and add it to result
+        context.addOptionContext(optionContext);
 
-        return result;
     }
 
     /**
      * Cette méthode permet d'instancier une option à partir des valeurs
-     *  détectées dans le contexte d'option.
+     * détectées dans le contexte d'option.
+     * <p/>
+     * Le context a été vérifié auparavant et on sait que l'option et ses
+     * arguments sont valides.
      * <p/>
      *
      * @param context le contexte d'une option parsée
      */
-    public void instanciateOption(OptionContext context) {
-
-        OptionDefinition definition = context.definition;
-
-        String optionName = definition.getName();
+    protected void instanciateOption(OptionContext context) {
 
         int position = 0;
 
         List<OptionArgument> arguments = new ArrayList<OptionArgument>();
 
-        for (OptionArgumentContext entry : context.argumentsFound) {
+        for (OptionArgumentContext argumentContext : context.argumentsFound) {
+            // get argument from command line
+            String argument = argumentContext.getArgument();
 
-            String argument = entry.getArgument();
+            // get argument definition
+            OptionArgumentDefinition argumentDefinition = argumentContext.getDefinition();
 
-            OptionArgumentDefinition optionArgumentDefinition = entry.getDefinition();
+            // extract value as String for the argument type
+            String valueStr = argumentDefinition.getType().extractArgumentValue(argument);
 
-            boolean mandatory = optionArgumentDefinition.getPosition() > -1;
+            // convert to matching type from argument definition value type
+            Object value = ConvertUtils.convert(valueStr, argumentDefinition.getValueType().getClazz());
 
-            // extract value
-            String valueStr = optionArgumentDefinition.getType().extractArgumentValue(argument);
+            // add argument to option
+            addOptionArgument(position, argument, argumentDefinition, value, arguments);
 
-            Object value = ConvertUtils.convert(valueStr, optionArgumentDefinition.getValueType().getClazz());
+            if (argumentDefinition.isMandatory()) {
+                // increments next mandatory position
+                position++;
+            }
+        }
+        // finally instanciate option and store it
+        addOption(context, arguments);
+    }
 
-            OptionArgument optionArgument = new OptionArgument<Object>(optionArgumentDefinition.key, position, argument, value);
 
-            // on sauvegarde l'argument dans l'option
-            arguments.add(optionArgument);
+    protected void checkPostParsing() throws OptionParserException {
+        // build a map from context
+        Map<OptionDefinition, List<OptionContext>> map;
+        map = new HashMap<OptionDefinition, List<OptionContext>>();
+        for (OptionContext optionContext : context.optionContexts) {
+            OptionDefinition definition = optionContext.definition;
+            List<OptionContext> list = map.get(definition);
+            if (list == null) {
+                map.put(definition, list = new ArrayList<OptionContext>());
+            }
+            list.add(optionContext);
+        }
 
-            if (mandatory) {
-                position++;
+        for (OptionDefinition definition : context.definitions) {
+            List<OptionContext> contextList = map.get(definition);
+            int min = definition.getMin();
+            int max = definition.getMax();
+
+            if ((contextList == null || contextList.isEmpty()) && min > 0) {
+                // fatal error mandatory option
+                throw new OptionParserException("");
+            }
+
+            if (min > 0 && (contextList == null || contextList.size() < min)) {
+                // fatal error required more (min>found)
+                throw new OptionParserException("");
+            }
+
+            if (max > 0 && (contextList != null && contextList.size() > max)) {
+                // fatal error required less (found>max)
+                throw new OptionParserException("");
+            }
+            //TODO check each argument option
+            if (contextList != null) {
+                for (OptionContext optionContext : contextList) {
+                    checkPostParsingOption(optionContext);
+                }
+            }
+        }
+        // clear map
+        map.clear();
+    }
+
+    protected void checkPostParsingOption(OptionContext optionContext) {
+
+        int max = context.getMaxMandatories(optionContext.definition);
+
+        for (int i = 0; i < max; i++) {
+            // check cardinalite
+
+        }
+
+        for (OptionArgumentContext argumentContext : optionContext.argumentsFound) {
+            // check there is no mandatory argument missing
+            if (argumentContext == null) {
+                //TODO
             }
         }
+    }
 
+    protected void addOption(OptionContext optionContext, List<OptionArgument> arguments) {
         Option option;
+        OptionKeyFactory.OptionKey key;
+
+        OptionDefinition definition = optionContext.definition;
+
+        key = OptionKeyFactory.getOptionKey(definition.getName());
+
         if (arguments.isEmpty()) {
-            option = new Option(definition, context.alias);
+            option = new Option(key, definition, optionContext.alias);
         } else {
-            option = new Option(definition, context.alias, arguments.toArray(new OptionArgument[arguments.size()]));
+            option = new Option(key, definition, optionContext.alias,
+                    arguments.toArray(new OptionArgument[arguments.size()]));
         }
-        List<Option> list = options.get(optionName);
+
+        List<Option> list = context.options.get(key);
         if (list == null) {
-            options.put(optionName, list = new ArrayList<Option>());
+            context.options.put(key, list = new ArrayList<Option>());
         }
         list.add(option);
-        parsedOptions.add(option);
+        context.parsedOptions.add(option);
     }
 
-    protected void checkPostParsing(List<OptionContext> contexts) {
-        // on verifie que les options obligatoires sont présentes
-        for (OptionDefinition definition : definitionFactory.getOptions()) {
-            if (definition.getMin() > 0) {
-                // option obligatoire
+    protected void addOptionArgument(int position, String argument,
+                                     OptionArgumentDefinition definition,
+                                     Object value, List<OptionArgument> arguments) {
+        // get unique argument key
+        OptionKeyFactory.OptionArgumentKey argumentKey = OptionKeyFactory.getArgumentKey(definition);
 
-            }
+        // get real position for this argument (-1 for an optional one)
+        int realPosition = definition.isMandatory() ? position : OptionArgumentDefinition.OPTIONAL_POSITION;
 
-        }
+        // instanciate concrete argument
+        OptionArgument optionArgument = new OptionArgument<Object>(argumentKey, realPosition, argument, value);
+
+        // on sauvegarde l'argument dans l'option
+        arguments.add(optionArgument);
     }
 
-    protected static class OptionArgumentContext {
+    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;
+    }
 
-        protected final OptionArgumentDefinition definition;
+}
 
-        protected final String argument;
+/**
+ * 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 {
 
-        protected final int commandLinePosition;
+    /** la liste des définitions d'options connues */
+    protected final OptionDefinition[] definitions;
 
-        public OptionArgumentContext(OptionArgumentDefinition definition, String argument, int commandLinePosition) {
-            this.argument = argument;
-            this.commandLinePosition = commandLinePosition;
-            this.definition = definition;
-        }
+    /**
+     * 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;
 
-        public String getArgument() {
-            return argument;
-        }
+    /** liste a plat de toutes les options lus. */
+    protected final List<Option> parsedOptions;
 
-        public OptionArgumentDefinition getDefinition() {
-            return definition;
-        }
-    }
+    /** 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;
+
+    /** la liste des contextes d'options détectés */
+    protected final List<OptionContext> optionContexts;
 
     /**
-     * Cette classe contient une option et ses arguments récupérés avant le
-     * parsing de l'option.
-     *
-     * @author chemit
+     * La liste des arguments qui ne sont pas des options insérés dans leur
+     * ordre d'apparition dans la ligne de commande
      */
-    protected static class OptionContext {
+    protected final List<String> arguments;
 
-        /** definition of option */
-        protected final OptionDefinition definition;
 
-        /** alias used for this option */
-        protected final String alias;
+    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()]);
 
-        /** the position of this option in the command line */
-        protected final int commandLinePosition;
+    }
 
-        /** liste des définitions arguments obligatoires par position obligatoire */
-        protected final OptionArgumentDefinition[][] mandatories;
+    void addOptionContext(OptionContext context) {
+        if (context != null) {
+            optionContexts.add(context);
+        }
+    }
 
-        /** la liste des définitions d'arguments optionnels */
-        protected final 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 context d'arguments trouvés */
-        protected final List<OptionArgumentContext> argumentsFound;
+    int getMaxMandatories(OptionDefinition definition) {
+        OptionArgumentDefinition[][] result = mandatories.get(definition);
+        if (result == null) {
+            build(definition);
+            result = mandatories.get(definition);
+        }
+        return result.length;
+    }
 
-        /** la position obligatoire courante */
-        protected int mandatoryPosition;
+    OptionArgumentDefinition[] getOptionals(OptionDefinition definition) {
+        OptionArgumentDefinition[] result = optionals.get(definition);
+        if (result == null) {
+            build(definition);
+            result = optionals.get(definition);
+        }
+        return result;
+    }
 
-        public OptionContext(OptionDefinition definition, String alias, int commandLinePosition) {
-            this.definition = definition;
-            this.alias = alias;
-            this.commandLinePosition = commandLinePosition;
-            this.argumentsFound = new ArrayList<OptionArgumentContext>();
+    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;
+            }
+            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();
+    }
 
-            // construit les tables d'arguments optionels et obligatoires
+    public void clear() {
+        mandatories.clear();
+        optionals.clear();
+        indexAlias.clear();
+        optionContexts.clear();
+    }
 
-            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>());
+    public OptionDefinition getDefinition(OptionKeyFactory.OptionKey key) {
+        for (OptionDefinition definition : definitions) {
+            if (definition.getName().equals(key.name)) {
+                return definition;
             }
-            for (OptionArgumentDefinition argument : argumentDefinitions) {
-                if (argument.getPosition() == -1) {
-                    _optionals.add(argument);
-                    continue;
-                }
-                int pos = argument.getPosition();
-                Collection<OptionArgumentDefinition> list = _mandatories.get(pos);
-                list.add(argument);
-            }
-            this.optionals = _optionals.toArray(new OptionArgumentDefinition[_optionals.size()]);
-            this.mandatories = new OptionArgumentDefinition[_mandatories.size()][];
-            for (int i = 0; i < mandatories.length; i++) {
-                Collection<OptionArgumentDefinition> _argumentDefinitions = _mandatories.get(i);
-                this.mandatories[i] = _argumentDefinitions.toArray(new OptionArgumentDefinition[_argumentDefinitions.size()]);
-            }
-            this.mandatoryPosition = 0;
         }
+        return null;
+    }
+}
 
-        public boolean isFull() {
-            return mandatoryPosition >= getMaxMandatory();
-        }
+/**
+ * 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 {
 
-        public int getMaxMandatory() {
-            return this.mandatories.length;
-        }
+    protected final OptionArgumentDefinition definition;
 
-        /**
-         * Tente d'ajouter un argument à l'option du context.
-         *
-         * @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.
-         */
-        public boolean addArgument(String argument, int position) {
+    protected final String argument;
 
-            OptionArgumentDefinition argumentDefinition = findArgument(argument);
+    protected final int commandLinePosition;
 
-            // find a matching argument definition
-            if (argumentDefinition != null) {
+    public OptionArgumentContext(OptionArgumentDefinition definition,
+                                 String argument, int commandLinePosition) {
+        this.argument = argument;
+        this.commandLinePosition = commandLinePosition;
+        this.definition = definition;
+    }
 
-                OptionArgumentContext argumentContext = new OptionArgumentContext(argumentDefinition, argument, position);
+    public String getArgument() {
+        return argument;
+    }
 
-                argumentsFound.add(argumentContext);
+    public OptionArgumentDefinition getDefinition() {
+        return definition;
+    }
+}
 
-                if (argumentDefinition.getPosition() > -1) {
-                    // was a mandatory argument increments mandatoryPosition
-                    mandatoryPosition++;
-                }
-            }
+/**
+ * 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 {
 
-            return argumentDefinition != null;
-        }
+    /** definition of option */
+    protected final OptionDefinition definition;
 
-        protected OptionArgumentDefinition findArgument(String argument) {
+    /** alias used for this option */
+    protected final String alias;
 
-            OptionArgumentDefinition result;
+    /** the position of this option in the command line */
+    protected final int commandLinePosition;
 
-            OptionArgumentType type;
+    /** la liste des context d'arguments trouvés */
+    protected final List<OptionArgumentContext> argumentsFound;
 
-            OptionArgumentDefinition[] defs = mandatories[mandatoryPosition];
+    /** la position obligatoire courante */
+    protected int mandatoryPosition;
 
-            if (argument.indexOf('=') > -1) {
-                String key = argument.substring(0, argument.indexOf('='));
-                type = OptionArgumentType.namedAndValued;
+    OptionContext(OptionDefinition definition, String alias, int commandLinePosition) {
+        this.definition = definition;
+        this.alias = alias;
+        this.commandLinePosition = commandLinePosition;
+        this.argumentsFound = new ArrayList<OptionArgumentContext>();
+        this.mandatoryPosition = 0;
+    }
 
-                // find in a optional first
-                result = findArgumentByTypeAndKey(type, key, optionals);
-                if (result == null) {
-                    // find a mandatory option                    
-                    result = findArgumentByTypeAndKey(type, key, defs);
-                }
-                return result;
-            }
+    /**
+     * 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) {
 
-            type = OptionArgumentType.constant;
+        OptionArgumentDefinition argumentDefinition = findArgument(parserContext, argument);
 
-            // find in a constant optional
-            result = findArgumentByTypeAndKey(type, argument, optionals);
-            if (result != null) {
-                return result;
-            }
+        // find a matching argument definition
+        if (argumentDefinition != null) {
+
+            OptionArgumentContext argumentContext = new OptionArgumentContext(argumentDefinition, argument, position);
 
-            // find a constant mandatory option
-            result = findArgumentByTypeAndKey(type, argument, defs);
-            if (result != null) {
-                return result;
+            argumentsFound.add(argumentContext);
+
+            if (argumentDefinition.getPosition() > -1) {
+                // was a mandatory argument increments mandatoryPosition
+                mandatoryPosition++;
             }
+        }
 
-            type = OptionArgumentType.valued;
+        return argumentDefinition != null;
+    }
 
-            OptionArgumentValueType valueType;
+    OptionArgumentDefinition findArgument(ParserContext parserContext, String argument) {
 
-            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
+        OptionArgumentDefinition result;
 
-            // find a valued optinal
-            result = findArgumentByTypeAndValueType(type, valueType, optionals);
-            if (result != null) {
-                return result;
-            }
+        OptionArgumentType type;
+
+        OptionArgumentDefinition[] defs = parserContext.getMandatories(definition, mandatoryPosition);
 
-            // find a valued mandatory option
+        OptionArgumentDefinition[] optionals = parserContext.getOptionals(definition);
+
+        if (argument.indexOf('=') > -1) {
+            String key = argument.substring(0, argument.indexOf('='));
+            type = OptionArgumentType.namedAndValued;
+
+            // find in a optional first
+            result = findArgumentByTypeAndKey(type, key, optionals);
             if (result == null) {
-                result = findArgumentByTypeAndValueType(type, valueType, defs);
+                // find a mandatory option
+                result = findArgumentByTypeAndKey(type, key, defs);
             }
-
             return result;
         }
 
-        protected OptionArgumentDefinition findArgumentByTypeAndKey(OptionArgumentType type,
-                                                                    String key,
-                                                                    OptionArgumentDefinition... defs) {
-            for (OptionArgumentDefinition argumentDefinion : defs) {
-                if (argumentDefinion.getType() == type && argumentDefinion.getKey().equals(key)) {
-                    return argumentDefinion;
-                }
-            }
-            return null;
+        type = OptionArgumentType.constant;
+
+        // find in a constant optional
+        result = findArgumentByTypeAndKey(type, argument, optionals);
+        if (result != null) {
+            return result;
         }
 
-        protected OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type,
-                                                                          OptionArgumentValueType valueType,
-                                                                          OptionArgumentDefinition... defs) {
-            for (OptionArgumentDefinition argumentDefinion : defs) {
-                if (argumentDefinion.getType() == type && argumentDefinion.getValueType() == valueType) {
-                    return argumentDefinion;
-                }
-            }
-            return null;
+        // find a constant mandatory option
+        result = findArgumentByTypeAndKey(type, argument, defs);
+        if (result != null) {
+            return result;
         }
-    }
 
-    /** @return la liste des arguments non lus par les options. */
-    public List<String> getArguments() {
-        return arguments;
-    }
+        type = OptionArgumentType.valued;
 
-    /** @return la chaine de caratère utilisée pour l'usage */
-    public String getName() {
-        return name;
-    }
+        OptionArgumentValueType valueType;
 
-    /**
-     * Permet de savoir si une option a ete trouvée sur la ligne de commande
-     *
-     * @param optionName le nom de l'option dont il faut vérifier l'existance
-     * @return vrai si l'option existe sur la ligne de commande
-     */
-    public boolean hasParsedOption(String optionName) {
-        return getParsedOptions(optionName).size() != 0;
-    }
+        valueType = OptionArgumentValueType.findTypeFromArgument(argument);
 
-
-    /**
-     * Retourne le premier argument d'un certain type
-     *
-     * @param optionName le nom de l'option à retourner
-     * @return la valeur de l'option si elle existe, null sinon
-     */
-    public Object[] getParsedOption(String optionName) {
-        List<Option> list = getParsedOptions(optionName);
-        if (list.size() == 0) {
-            return null;
-        } else {
-            return list.get(0).getArguments();
+        // find a valued optinal
+        result = findArgumentByTypeAndValueType(type, valueType, optionals);
+        if (result != null) {
+            return result;
         }
-    }
 
-    /**
-     * Retourne la valeur d'un argument donné pour une option donéee
-     *
-     * @param optionName  le nom de l'option à retourner
-     * @param argumentKey le nom de l'argument
-     * @return la valeur de l'option si elle existe, null sinon
-     */
-    public Object getParsedOption(String optionName, String argumentKey) {
-        List<Option> list = getParsedOptions(optionName);
-        if (list.size() == 0) {
-            return null;
-        } else {
-            Option arguments1 = list.get(0);
-            return arguments1.getArgumentValue(argumentKey);
+        // find a valued mandatory option
+        if (result == null) {
+            result = findArgumentByTypeAndValueType(type, valueType, defs);
         }
-    }
 
-    /**
-     * Retourne la liste de toutes les options créées durant le parsage de la
-     * ligne de commande.
-     *
-     * @return la liste de toutes les options lus
-     */
-    public List<Option> getParsedOptions() {
-        return parsedOptions;
+        return result;
     }
 
-    /**
-     * Retourne la liste de toutes les options d'un certain type
-     *
-     * @param optionName le nom des options à retourner
-     * @return la liste des options d'un certain nom, ou une liste vide si
-     *         aucune option de ce nom existe ou si cette option n'a pas été trouvé
-     *         sur la ligne de commande
-     */
-    public List<Option> getParsedOptions(String optionName) {
-        for (String option : options.keySet()) {
-            if (optionName.equals(option)) {
-                return options.get(option);
+    OptionArgumentDefinition findArgumentByTypeAndKey(OptionArgumentType type,
+                                                      String key,
+                                                      OptionArgumentDefinition... defs) {
+        for (OptionArgumentDefinition argumentDefinion : defs) {
+            if (argumentDefinion.getType() == type && argumentDefinion.getKey().equals(key)) {
+                return argumentDefinion;
             }
         }
-        // aucune option trouvée avec le nom donné
-        return Collections.emptyList();
+        return null;
     }
 
+    OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type,
+                                                            OptionArgumentValueType valueType,
+                                                            OptionArgumentDefinition... defs) {
+        for (OptionArgumentDefinition argumentDefinion : defs) {
+            if (argumentDefinion.getType() == type && argumentDefinion.getValueType() == valueType) {
+                return argumentDefinion;
+            }
+        }
+        return null;
+    }
 }
\ No newline at end of file