Index: lutinutil/src/java/org/codelutin/util/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/util/OptionParser.java:1.9 lutinutil/src/java/org/codelutin/util/OptionParser.java:1.10
--- lutinutil/src/java/org/codelutin/util/OptionParser.java:1.9	Thu Dec 13 01:29:10 2007
+++ lutinutil/src/java/org/codelutin/util/OptionParser.java	Fri Dec 14 18:46:46 2007
@@ -78,34 +78,20 @@
 
     public static final String APPLICATION_ARGUMENTS_FIELD_NAME = "applicationArguments";
 
-    Option applicationArguments;
-
-    public Option getApplicationArguments() {
-        return applicationArguments;
-    }
-
-    public void setApplicationArguments(Option applicationArguments) {
-        this.applicationArguments = applicationArguments;
-    }
-
     /** logger non statique pour épouser la catégorie de l'implantation */
     protected final LutinLog log = LutinLogFactory.getLutinLog(getClass());
 
     /** l'annotation de définition du parseur */
-    protected final ApplicationA _anno;
+    protected final ApplicationA annotation;
 
     /** la liste des définitions d'options connues */
-    protected final Map<String, OptionDefinition> _odefinitions;
+    protected final Map<String, OptionDefinition> definitions;
 
     /** le dictionnaire des definitions d'options indexées par leurs alias */
-    protected final Map<String, OptionDefinition> _indexAlias;
-
-    /** le dictionnaire d'actions associées aux options */
-    protected final Map<String, OptionAction> _actions;
-
+    protected final Map<String, OptionDefinition> indexAlias;
 
     /** la liste des options trouvées et valides, indexées par leur clef unique. */
-    protected final Map<String, List<Option>> _acceptedOptions;
+    protected final Map<String, List<Option>> acceptedOptions;
 
     /** list of errors found while parsing */
     protected OptionParserException[] _errors;
@@ -122,23 +108,21 @@
                 throw new IllegalArgumentException(_("lutinutil.parser.unfound.annotation", ApplicationA.class, this));
             }
         }
-        this._anno = anno;
-        this._acceptedOptions = new HashMap<String, List<Option>>();
-        this._actions = new HashMap<String, OptionAction>();
-
-        this._odefinitions = new LinkedHashMap<String, OptionDefinition>();
-        this._indexAlias = new TreeMap<String, OptionDefinition>();
+        this.annotation = anno;
+        this.acceptedOptions = new HashMap<String, List<Option>>();
+        this.definitions = new LinkedHashMap<String, OptionDefinition>();
+        this.indexAlias = new TreeMap<String, OptionDefinition>();
 
         if (anno.options().length > 0) {
             // parser have some available options
             for (OptionA optionA : anno.options()) {
                 // build each definition from his associated OptionA
                 OptionDefinition definition = new OptionDefinition(optionA);
-                _odefinitions.put(optionA.key(), definition);
-                _acceptedOptions.put(optionA.key(), new ArrayList<Option>());
+                definitions.put(optionA.key(), definition);
+                acceptedOptions.put(optionA.key(), new ArrayList<Option>());
                 // keep all alias of the option
                 for (String alias : optionA.alias()) {
-                    _indexAlias.put(alias, definition);
+                    indexAlias.put(alias, definition);
                 }
             }
         }
@@ -172,7 +156,7 @@
     }
 
     private void cleanResult() {
-        for (Map.Entry<String, List<Option>> stringListEntry : _acceptedOptions.entrySet()) {
+        for (Map.Entry<String, List<Option>> stringListEntry : acceptedOptions.entrySet()) {
             stringListEntry.getValue().clear();
         }
         _errors = null;
@@ -180,17 +164,21 @@
 
     public Option[] getOptions() {
         List<Option> result = new ArrayList<Option>();
-        for (List<Option> options : _acceptedOptions.values()) {
+        for (List<Option> options : acceptedOptions.values()) {
             result.addAll(options);
         }
         return result.toArray(new Option[result.size()]);
     }
 
     public boolean isOptionEnabled(String key) {
-        List<Option> list = _acceptedOptions.get(key);
+        List<Option> list = acceptedOptions.get(key);
         return list != null && !list.isEmpty();
     }
 
+    public Map<String, List<Option>> getAcceptedOptions() {
+        return acceptedOptions;
+    }
+
     /**
      * Cette classe contient les index utilisés pendant le parsing.
      * <p/>
@@ -316,7 +304,7 @@
                 // a fully option was detected
                 log.info("pos " + start + " : " + alias + " " + argsForOption);
                 // find definition from alias
-                OptionDefinition definition = _indexAlias.get(alias);
+                OptionDefinition definition = indexAlias.get(alias);
                 if (definition == null) {
                     //fatal error : unknown.option
                     addError(_("lutinutil.parser.unknown.option", alias, start));
@@ -405,7 +393,7 @@
 
         private void checkAndAddOption(String alias, OptionDefinition definition, OptionArgument[] arguments) {
 
-            List<Option> listFound = _acceptedOptions.get(definition.key);
+            List<Option> listFound = acceptedOptions.get(definition.key);
 
             if (definition.max > -1 && listFound.size() == definition.max) {
                 // too much optioof this option
@@ -422,8 +410,8 @@
             // everything is ok, can instance option
             try {
                 Class<? extends Option> clazz = definition.getImpl();
-                Constructor<? extends Option> cons = clazz.getConstructor(String.class, OptionAction.class, OptionArgument[].class);
-                Option result = cons.newInstance(alias, _actions.get(definition.key), arguments);
+                Constructor<? extends Option> cons = clazz.getConstructor(String.class, OptionArgument[].class);
+                Option result = cons.newInstance(alias, arguments);
                 listFound.add(result);
             } catch (Exception e) {
                 throw new RuntimeException(e);
@@ -496,11 +484,11 @@
 
 
         public OptionDefinition getOptionDefinition(String key) {
-            return _odefinitions.get(key);
+            return definitions.get(key);
         }
 
         public OptionGroupArgumentDefinition[] getOptionalGroupDefinition(String key) {
-            OptionDefinition definition = _odefinitions.get(key);
+            OptionDefinition definition = definitions.get(key);
             List<OptionGroupArgumentDefinition> result = new ArrayList<OptionGroupArgumentDefinition>();
             for (OptionGroupArgumentDefinition group : definition.groups) {
                 if (!group.isMandatory()) {
@@ -511,7 +499,7 @@
         }
 
         public OptionGroupArgumentDefinition[] getMandatoryGroupDefinition(String key) {
-            OptionDefinition definition = _odefinitions.get(key);
+            OptionDefinition definition = definitions.get(key);
             List<OptionGroupArgumentDefinition> result = new ArrayList<OptionGroupArgumentDefinition>();
             for (OptionGroupArgumentDefinition group : definition.groups) {
                 if (group.isMandatory()) {
@@ -520,13 +508,11 @@
             }
             return result.toArray(new OptionGroupArgumentDefinition[result.size()]);
         }
-
-
     }
 
 
     public Option[] getOptions(String key) {
-        List<Option> list = _acceptedOptions.get(key);
+        List<Option> list = acceptedOptions.get(key);
         return list == null || list.isEmpty() ? null : list.toArray(new Option[list.size()]);
     }
 
@@ -534,7 +520,7 @@
         String head = _("lutinutil.parserdef.printUsage.head", name);
         String prefixO = _("lutinutil.parserdef.printUsage.options.head", name);
         String prefix = "\n";
-        w.append(OptionParserUtil.toString(_anno, head, prefixO, prefix));
+        w.append(OptionParserUtil.toString(annotation, head, prefixO, prefix));
     }
 
     /**
@@ -557,27 +543,6 @@
     public boolean hasFailed() {
         return _errors != null && _errors.length > 0;
     }
-
-
-    /**
-     * Register an action associated to an Option.
-     *
-     * @param optionKey option key
-     * @param action    action to realise for the option
-     * @throws IllegalArgumentException if option key is unknown, or an action
-     *                                  is already registered for the option key
-     *                                  given.
-     */
-    public void registerAction(String optionKey, OptionAction action) throws IllegalArgumentException {
-        if (!_odefinitions.containsKey(optionKey)) {
-            throw new IllegalArgumentException(_("lutinutil.parser.unfound.option", optionKey));
-        }
-        if (_actions.containsKey(optionKey)) {
-            throw new IllegalArgumentException(_("lutinutil.parser.action.already.registred", optionKey));
-        }
-        _actions.put(optionKey, action);
-    }
-
 }