Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.5 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.6
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.5	Wed Nov 28 20:57:16 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Thu Nov 29 22:25:29 2007
@@ -29,7 +29,9 @@
 
 import java.io.IOException;
 import java.io.Writer;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -78,7 +80,7 @@
         }
     }
 
-    final org.apache.commons.logging.Log log;
+    protected final org.apache.commons.logging.Log log;
 
     /** le context du parseur (contenant les données temporaires du parsing). */
     protected final ParserContext context;
@@ -90,7 +92,7 @@
      * la liste des options, la cle est le nom de l'option, et la valeur
      * est la liste des options qui ont été lues grâce à celle-ci.
      */
-    protected final HashMap<String, List<Option>> options;
+    protected final Map<String, List<Option>> options;
 
     /**
      * La liste des arguments qui ne sont pas des options insérés dans leur
@@ -98,6 +100,8 @@
      */
     protected final List<String> arguments;
 
+    protected final Map<String, OptionAction> actions;
+
     public OptionParser() {
 
         // find the fullyQualifiedFactoryName via OptionParserA annotation
@@ -107,12 +111,12 @@
             throw new IllegalArgumentException("could not found annotation " +
                     OptionParserA.class + " in Parser " + this);
         }
-        log = LogFactory.getLog(getClass());
-
+        this.log = LogFactory.getLog(getClass());
 
         this.definitions = new LinkedHashMap<String, OptionDefinition>();
         this.arguments = new ArrayList<String>();
         this.options = new HashMap<String, List<Option>>();
+        this.actions = new HashMap<String, OptionAction>();
         try {
             Map<String, OptionDefinition> map;
             OptionDefinitionA defA;
@@ -134,16 +138,36 @@
             }
             keys1.clear();
             map.clear();
-
             // create parser context
             context = new ParserContext(this.definitions);
 
         } catch (NoSuchFieldException e) {
             throw new IllegalArgumentException(e);
         }
+    }
 
+    /**
+     * Register an action associated to an Option.
+     *
+     * @param optionKey option key
+     * @param action    action to realise for the option
+     */
+    public void registerAction(String optionKey, OptionAction action) {
+        if (!definitions.containsKey(optionKey)) {
+            throw new IllegalArgumentException("could not found this option " + optionKey);
+        }
+        if (actions.containsKey(optionKey)) {
+            throw new IllegalArgumentException("already action registred for this option " + optionKey);
+        }
+        actions.put(optionKey, action);
     }
 
+    /**
+     * Launch parsing of some arguments.
+     *
+     * @param args arguments to parse
+     * @throws OptionParserException if any problem while parsing
+     */
     public void doParse(String... args) throws OptionParserException {
         if (args.length > 0) {
             // detect OptionContexts
@@ -220,8 +244,8 @@
                 // close the current optionContexts and add it to result
                 context.addOptionContext(optionContext);
 
-
-                optionContext = new OptionContext(newOption, argument, i);
+                optionContext = new OptionContext(newOption,
+                        actions.get(newOption.getName()),argument,i);
                 continue;
             }
             if (optionContext == null || !optionContext.addArgument(context, argument, i)) {
@@ -286,17 +310,10 @@
                 position++;
             }
         }
-        // finally instanciate option and store it
-        Option option;
 
+        // finally instanciate option and store it
         String key = optionContext.definition.getName();
-
-        if (arguments.isEmpty()) {
-            option = new Option(optionContext.alias);
-        } else {
-            option = new Option(optionContext.alias,
-                    arguments.toArray(new OptionArgument[arguments.size()]));
-        }
+        Option option = optionContext.newOption(arguments);
         List<Option> list = options.get(key);
         if (list == null) {
             options.put(key, list = new ArrayList<Option>());
@@ -401,6 +418,7 @@
 
         void addOptionContext(OptionContext context) {
             if (context != null) {
+                log.info("[" + context.alias + "] : " + context.definition);
                 optionContexts.add(context);
             }
         }
@@ -497,18 +515,39 @@
         /** la liste des context d'arguments trouvés */
         protected final List<OptionArgumentContext> argumentsFound;
 
+        protected final OptionAction action;
+
         /** la position obligatoire courante */
         protected int mandatoryPosition;
 
 
-        OptionContext(OptionDefinition definition, String alias, int commandLinePosition) {
+        OptionContext(OptionDefinition definition,OptionAction action,  String alias, int commandLinePosition) {
             this.definition = definition;
             this.alias = alias;
+            this.action=action;
             this.commandLinePosition = commandLinePosition;
             this.argumentsFound = new ArrayList<OptionArgumentContext>();
             this.mandatoryPosition = 0;
         }
 
+        Option newOption(List<OptionArgument> arguments) {
+            try {
+                Class<? extends Option> clazz = definition.getImpl();
+                Constructor<? extends Option> cons = clazz.getConstructor(String.class,OptionAction.class, OptionArgument[].class);
+                Option result;
+                result = cons.newInstance(alias, action,arguments.toArray(new OptionArgument[arguments.size()]));
+                return result;
+            } catch (InstantiationException e) {
+                throw new RuntimeException(e);
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            } catch (InvocationTargetException e) {
+                throw new RuntimeException(e);
+            } catch (NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
         /**
          * Tente d'ajouter un argument à l'option du context.
          *
@@ -549,13 +588,14 @@
             boolean named = argument.indexOf('=') > -1;
 
             if (defs.length > 0) {
+                // always try to find a mandatory argument first
                 result = findArgument0(named, argument, defs);
             }
 
             if (result == null && optionals.length > 0) {
                 result = findArgument0(named, argument, optionals);
             }
-            log.info("[" + argument + "] :" + result);
+            log.info(result + " : [" + argument + "]");
             return result;
         }
 
@@ -566,28 +606,26 @@
                 String key = argument.substring(0, argument.indexOf('='));
                 type = OptionArgumentType.namedAndValued;
 
-                // find in a optional first
+                // find a named and valued
                 result = findArgumentByTypeAndKey(type, key, defs);
 
                 return result;
             }
 
             type = OptionArgumentType.constant;
-
-            // find in a constant optional
+            // find in a constant
             result = findArgumentByTypeAndKey(type, argument, defs);
             if (result != null) {
                 return result;
             }
 
-
             type = OptionArgumentType.valued;
 
             OptionArgumentValueType valueType;
 
             valueType = OptionArgumentValueType.findTypeFromArgument(argument);
 
-            // find a valued optinal
+            // find a valued
             result = findArgumentByTypeAndValueType(type, valueType, defs);
             if (result != null) {
                 return result;