Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u /dev/null lutinutil/src/java/org/codelutin/util/OptionParser.java:1.1
--- /dev/null	Mon Nov 19 20:50:17 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Mon Nov 19 20:50:12 2007
@@ -0,0 +1,535 @@
+/* *##%
+* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Code Lutin,
+*    Cédric Pineau, Benjamin Poussin,
+*
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* 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 java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * Parser d'options de la ligne de commande.
+ *
+ * @author poussin
+ * @author chemit
+ */
+public class OptionParser {
+
+    public static OptionParser doParse(String name,
+                                       String fullyQualifiedFactoryName,
+                                       String... args)
+            throws OptionParserException {
+
+        OptionParser parser;
+
+        parser = new OptionParser(name);
+
+        Map<String, OptionDefinition> indexAlias = parser.init(fullyQualifiedFactoryName);
+        List<OptionContext> contexts = null;
+
+        if (args.length > 0) {
+
+            // detection des contexts d'options
+            contexts = parser.detectOptionContexts(indexAlias, args);
+        }
+
+        // verification de la coherence des options détectée par rapport aux
+        // definitions des options
+        parser.checkPostParsing(contexts);
+
+        if (contexts != null && !contexts.isEmpty()) {
+            for (OptionContext context : contexts) {
+                parser.instanciateOption(context);
+            }
+            // on vide les contextes
+            contexts.clear();
+        }
+
+        return parser;
+    }
+
+
+    /** l'usine de définitions d'options */
+    protected OptionDefinitionFactory definitionFactory;
+
+    /** La liste des arguments qui ne sont pas des options */
+    protected List<String> arguments;
+
+    /** le nom à afficher pour l'usage */
+    protected String name;
+
+    /**
+     * 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;
+
+    /** liste a plat de toutes les options lus. */
+    protected List<Option> parsedOptions;
+
+    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 void printUsage(Writer writer) {
+        try {
+            definitionFactory.printUsage(writer, this.name);
+        } catch (IOException e) {
+            // should never appear
+            throw new RuntimeException(e);
+        }
+    }
+
+    @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);
+        }
+    }
+
+    /**
+     * Detecte les options et leurs arguments, à partir de la suite des
+     * arguments donnés et construit la liste des context 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
+     */
+    protected List<OptionContext> detectOptionContexts(Map<String, OptionDefinition>
+            indexAlias, String... args) {
+        List<OptionContext> result = new ArrayList<OptionContext>();
+
+        OptionContext context = null;
+
+        for (int i = 0; i < args.length; i++) {
+            String argument = args[i];
+            if (argument.startsWith("-")) {
+                // an alias detected
+                OptionDefinition newOption = indexAlias.get(argument);
+                if (newOption == null) {
+                    // unknown option
+                    arguments.add(argument);
+                    continue;
+                }
+                if (context != null) {
+                    // close the current context and add it to result
+                    result.add(context);
+                }
+                context = new OptionContext(newOption, argument, i);
+                continue;
+            }
+            if (context == null || !context.addArgument(argument, i)) {
+                // no option opened or argumnet not accepted
+                arguments.add(argument);
+            }
+        }
+
+        if (context != null) {
+            // close the current context and add it to result
+            result.add(context);
+        }
+
+        return result;
+    }
+
+    /**
+     * Cette méthode permet d'instancier une option à partir des valeurs
+     *  détectées dans le contexte d'option.
+     * <p/>
+     *
+     * @param context le contexte d'une option parsée
+     */
+    public void instanciateOption(OptionContext context) {
+
+        OptionDefinition definition = context.definition;
+
+        String optionName = definition.getName();
+
+        int position = 0;
+
+        List<OptionArgument> arguments = new ArrayList<OptionArgument>();
+
+        for (OptionArgumentContext entry : context.argumentsFound) {
+
+            String argument = entry.getArgument();
+
+            OptionArgumentDefinition optionArgumentDefinition = entry.getDefinition();
+
+            boolean mandatory = optionArgumentDefinition.getPosition() > -1;
+
+            // extract value
+            String valueStr = optionArgumentDefinition.getType().extractArgumentValue(argument);
+
+            Object value = ConvertUtils.convert(valueStr, optionArgumentDefinition.getValueType().getClazz());
+
+            OptionArgument optionArgument = new OptionArgument<Object>(optionArgumentDefinition.key, position, argument, value);
+
+            // on sauvegarde l'argument dans l'option
+            arguments.add(optionArgument);
+
+            if (mandatory) {
+                position++;
+            }
+        }
+
+        Option option;
+        if (arguments.isEmpty()) {
+            option = new Option(definition, context.alias);
+        } else {
+            option = new Option(definition, context.alias, arguments.toArray(new OptionArgument[arguments.size()]));
+        }
+        List<Option> list = options.get(optionName);
+        if (list == null) {
+            options.put(optionName, list = new ArrayList<Option>());
+        }
+        list.add(option);
+        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 static class OptionArgumentContext {
+
+        protected final OptionArgumentDefinition definition;
+
+        protected final String argument;
+
+        protected final int commandLinePosition;
+
+        public OptionArgumentContext(OptionArgumentDefinition definition, String argument, int commandLinePosition) {
+            this.argument = argument;
+            this.commandLinePosition = commandLinePosition;
+            this.definition = definition;
+        }
+
+        public String getArgument() {
+            return argument;
+        }
+
+        public OptionArgumentDefinition getDefinition() {
+            return definition;
+        }
+    }
+
+    /**
+     * Cette classe contient une option et ses arguments récupérés avant le
+     * parsing de l'option.
+     *
+     * @author chemit
+     */
+    protected static class OptionContext {
+
+        /** definition of option */
+        protected final OptionDefinition definition;
+
+        /** alias used for this option */
+        protected final String alias;
+
+        /** 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;
+
+        /** la liste des définitions d'arguments optionnels */
+        protected final OptionArgumentDefinition[] optionals;
+
+        /** la liste des context d'arguments trouvés */
+        protected final List<OptionArgumentContext> argumentsFound;
+
+        /** la position obligatoire courante */
+        protected int mandatoryPosition;
+
+        public OptionContext(OptionDefinition definition, String alias, int commandLinePosition) {
+            this.definition = definition;
+            this.alias = alias;
+            this.commandLinePosition = commandLinePosition;
+            this.argumentsFound = new ArrayList<OptionArgumentContext>();
+
+            // 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 = _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;
+        }
+
+        public boolean isFull() {
+            return mandatoryPosition >= getMaxMandatory();
+        }
+
+        public int getMaxMandatory() {
+            return this.mandatories.length;
+        }
+
+        /**
+         * 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) {
+
+            OptionArgumentDefinition argumentDefinition = findArgument(argument);
+
+            // find a matching argument definition
+            if (argumentDefinition != null) {
+
+                OptionArgumentContext argumentContext = new OptionArgumentContext(argumentDefinition, argument, position);
+
+                argumentsFound.add(argumentContext);
+
+                if (argumentDefinition.getPosition() > -1) {
+                    // was a mandatory argument increments mandatoryPosition
+                    mandatoryPosition++;
+                }
+            }
+
+            return argumentDefinition != null;
+        }
+
+        protected OptionArgumentDefinition findArgument(String argument) {
+
+            OptionArgumentDefinition result;
+
+            OptionArgumentType type;
+
+            OptionArgumentDefinition[] defs = mandatories[mandatoryPosition];
+
+            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) {
+                    // find a mandatory option                    
+                    result = findArgumentByTypeAndKey(type, key, defs);
+                }
+                return result;
+            }
+
+            type = OptionArgumentType.constant;
+
+            // find in a constant optional
+            result = findArgumentByTypeAndKey(type, argument, optionals);
+            if (result != null) {
+                return result;
+            }
+
+            // find a constant mandatory option
+            result = findArgumentByTypeAndKey(type, argument, defs);
+            if (result != null) {
+                return result;
+            }
+
+            type = OptionArgumentType.valued;
+
+            OptionArgumentValueType valueType;
+
+            valueType = OptionArgumentValueType.findTypeFromArgument(argument);
+
+            // find a valued optinal
+            result = findArgumentByTypeAndValueType(type, valueType, optionals);
+            if (result != null) {
+                return result;
+            }
+
+            // find a valued mandatory option
+            if (result == null) {
+                result = findArgumentByTypeAndValueType(type, valueType, 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;
+        }
+
+        protected OptionArgumentDefinition findArgumentByTypeAndValueType(OptionArgumentType type,
+                                                                          OptionArgumentValueType valueType,
+                                                                          OptionArgumentDefinition... defs) {
+            for (OptionArgumentDefinition argumentDefinion : defs) {
+                if (argumentDefinion.getType() == type && argumentDefinion.getValueType() == valueType) {
+                    return argumentDefinion;
+                }
+            }
+            return null;
+        }
+    }
+
+    /** @return la liste des arguments non lus par les options. */
+    public List<String> getArguments() {
+        return arguments;
+    }
+
+    /** @return la chaine de caratère utilisée pour l'usage */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * 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;
+    }
+
+
+    /**
+     * 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();
+        }
+    }
+
+    /**
+     * 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);
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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);
+            }
+        }
+        // aucune option trouvée avec le nom donné
+        return Collections.emptyList();
+    }
+
+}
\ No newline at end of file