Index: lutinutil/src/java/org/codelutin/option/OptionParser.java
diff -u lutinutil/src/java/org/codelutin/option/OptionParser.java:1.2 lutinutil/src/java/org/codelutin/option/OptionParser.java:1.3
--- lutinutil/src/java/org/codelutin/option/OptionParser.java:1.2	Sun Dec 30 23:42:59 2007
+++ lutinutil/src/java/org/codelutin/option/OptionParser.java	Mon Dec 31 05:29:01 2007
@@ -23,6 +23,7 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import static org.codelutin.i18n.I18n._;
+import org.codelutin.option.OptionParserContexts.OptionContext;
 import org.codelutin.option.OptionParserContexts.ParserContext;
 import org.codelutin.option.def.OptionDefinition;
 import org.codelutin.option.def.OptionDefinitionBuilder;
@@ -51,9 +52,16 @@
  * <b>Si on veut utiliser les actions des options (OptionAction), il faut avant
  * tout parsing, enregistrer les classes concretes d'implantation de ces actions.</b>
  * <p/>
- * Cela se fait en utilisant la méthode {@link #registerActions(Class[])}, les
+ * Cela se fait en utilisant la méthode {@link #registerActions(Class)}, les
  * implantations doivent être présentes en tant qu'inner class d'une ou plusieurs
  * classes container.
+ * <p/>
+ * Le fonctionnement est identique pour les config (celles générées sont abstraites),
+ * on doit enregistre des implantation concretes par l'intermédiaire de la méthode
+ * {@link #registerConfigs(Class[])}.
+ * <p/>
+ * <b>Attention, contrairement aux actions, ici les classes de Config ne sont
+ * pas des inner-classes.</b>
  */
 
 public abstract class OptionParser {
@@ -62,7 +70,7 @@
     protected final Log log = LogFactory.getLog(getClass());
 
     /**
-     * Cette méthode encapsule l'appel à la méthode statique <code>buildDefinition</code>
+     * Cette méthode encapsule l'appel à la méthode statique <code>buildDefinitions</code>
      * générée dans le parseur de classe <code>targetClass</code> et retourne
      * les définitions d'options obtenues par le builder utilisé.
      *
@@ -94,11 +102,6 @@
     /** les clefs d'options connues par le parseur */
     protected final List<ConfigKey> configKeys;
 
-    /** les options trouvées et valides, indexées par leur clef typée dans le dernier parsing */
-    protected Map<OptionKey, List<Option>> options;
-
-    protected Map<ConfigKey, Config> configs;
-
     /** les arguments non utilisés, indexés par leur position dans du dernier parsing */
     protected Map<Integer, String> unusedArguments;
 
@@ -114,21 +117,6 @@
     }
 
     /**
-     * Enregistre les implantations d'action à partir de plusieurs classes
-     * contenant des classes imbriquées d'implantation d'OptionAction.
-     * <p/>
-     * <b>Cette méthode doit être invoquée avant toute demande d'OptionAction
-     * après parsing.</b>
-     *
-     * @param clazz la liste des classes contenant des implantations d'OptionAction
-     */
-    public void registerActions(Class... clazz) {
-        for (Class aClass : clazz) {
-            registerActions(aClass);
-        }
-    }
-
-    /**
      * Enregistre les implantations d'action à partir d'une classe contenant
      * des classes imbriquées d'implantation d'OptionAction.
      *
@@ -145,35 +133,16 @@
     }
 
     /**
-     * Enregistre les implantations d'action à partir de plusieurs classes
-     * contenant des classes imbriquées d'implantation d'OptionAction.
-     * <p/>
-     * <b>Cette méthode doit être invoquée avant toute demande d'OptionAction
-     * après parsing.</b>
+     * Enregistre les implantations concretes des configs.
      *
-     * @param clazz la liste des classes contenant des implantations d'OptionAction
+     * @param clazz la liste des classes contenant des implantations de Config
      */
-    public void registerConfigs(Class... clazz) {
-        for (Class aClass : clazz) {
-            registerConfigs(aClass);
+    public void registerConfigs(Class<? extends Config>... clazz) {
+        for (Class<? extends Config> aClass : clazz) {
+            registerConfig(aClass);
         }
     }
 
-    /**
-     * Enregistre les implantations de config à partir d'une classe contenant
-     * des classes imbriquées d'implantation Config.
-     *
-     * @param clazz la classe contenant des implantations de Config
-     */
-    public void registerConfigs(Class clazz) {
-        // recherche des inner classes
-        Class<?>[] classes = clazz.getClasses();
-        for (Class<?> aClass : classes) {
-            if (Config.class.isAssignableFrom(aClass)) {
-                registerConfig(aClass);
-            }
-        }
-    }
 
     public List<ConfigKey> getConfigKeys() {
         return configKeys;
@@ -203,10 +172,12 @@
         context.detectOptions(args);
 
         // instanciate real options from safe contexts
-        options = context.instanciate();
+        for (OptionContext optionContext : context.getContexts()) {
+            optionContext.instanciate();
+        }
 
         // transfert unused arguments
-        for (Integer unusedArgument : context.unusedArguments) {
+        for (Integer unusedArgument : context.getUnusedArguments()) {
             unusedArguments.put(unusedArgument, args[unusedArgument]);
         }
 
@@ -223,17 +194,15 @@
      *         parsing correspondant à la clef donnée.
      */
     public boolean isOptionEnabled(OptionKey key) {
-        List<? extends Option> list = options.get(key);
-        return list != null && !list.isEmpty();
+        List list = key.getOptions();
+        return !list.isEmpty();
     }
 
     /** @return le nombre d'options valides trouvées lors du dernier parsing */
     public int getNbOptions() {
         int result = 0;
-        if (options != null) {
-            for (List<Option> optionList : options.values()) {
-                result += optionList.size();
-            }
+        for (OptionKey optionKey : optionKeys) {
+            result += optionKey.getOptions().size();
         }
         return result;
     }
@@ -245,7 +214,9 @@
      * @throws Exception si un problème pendant les actions
      */
     public void doAllActions() throws Exception {
-        doActions(optionKeys.toArray(new OptionKey[optionKeys.size()]));
+        if (getNbOptions() > 0) {
+            doActions(optionKeys.toArray(new OptionKey[optionKeys.size()]));
+        }
     }
 
     /**
@@ -270,7 +241,7 @@
      * @return une table des options trouvées ou un tableau vide
      */
     public <O extends Option> O[] getOptions(OptionKey<O, ?, ?> key) {
-        return ArrayUtil.toArray(options.get(key), key.getOptionClass());
+        return ArrayUtil.toArray(key.getOptions(), key.getOptionClass());
     }
 
     /**
@@ -373,9 +344,8 @@
      * @param key la clef non typée
      * @return la clef typée ou null si non trouvée.
      */
-    @SuppressWarnings({"unchecked"})
     protected ConfigKey<?> getConfigKey(String key) {
-        for (ConfigKey optionKey : configKeys) {
+        for (ConfigKey<?> optionKey : configKeys) {
             if (optionKey.getCategory().equals(key)) {
                 return optionKey;
             }
@@ -385,9 +355,8 @@
 
     /** nettoye les résultat du parseur (utilisé avant tout parsing) */
     protected void cleanResult() {
-        if (options != null) {
-            options.clear();
-            options = null;
+        for (OptionKey optionKey : optionKeys) {
+            optionKey.resetOptions();
         }
         if (unusedArguments != null) {
             unusedArguments.clear();
@@ -408,11 +377,11 @@
     }
 
     @SuppressWarnings({"unchecked"})
-    protected void registerConfig(Class<?> aClass) {
+    protected <C extends Config> void registerConfig(Class<? extends C> aClass) {
         for (ConfigKey key : configKeys) {
             if (key.getAbstractConfigClass().isAssignableFrom(aClass)) {
                 // found a matching key
-                key.setConfigClass(aClass);
+                ((ConfigKey<C>) key).setConfigClass(aClass);
             }
         }
     }

Index: lutinutil/src/java/org/codelutin/option/OptionParserContexts.java
diff -u lutinutil/src/java/org/codelutin/option/OptionParserContexts.java:1.1 lutinutil/src/java/org/codelutin/option/OptionParserContexts.java:1.2
--- lutinutil/src/java/org/codelutin/option/OptionParserContexts.java:1.1	Sun Dec 30 22:50:46 2007
+++ lutinutil/src/java/org/codelutin/option/OptionParserContexts.java	Mon Dec 31 05:29:02 2007
@@ -19,6 +19,7 @@
 package org.codelutin.option;
 
 import org.apache.commons.beanutils.ConvertUtils;
+import static org.codelutin.i18n.I18n._;
 import org.codelutin.option.def.ArgumentDefinition;
 import org.codelutin.option.def.ArgumentType;
 import org.codelutin.option.def.ArgumentValueType;
@@ -28,7 +29,6 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
@@ -87,7 +87,7 @@
             super(parent, withSons);
         }
 
-        protected abstract Object instanciate();
+        //protected abstract Object instanciate();
 
         protected ParserException newError(String content, Exception e) {
             ParserException e1;
@@ -199,12 +199,12 @@
                 OptionDefinition definition = indexAlias.get(alias);
                 if (definition == null) {
                     //fatal error : unknown option
-                    addError(org.codelutin.i18n.I18n._("lutinutil.parser.unknown.option", alias, start));
+                    addError(_("lutinutil.parser.unknown.option", alias, start));
                     continue;
                 }
                 if (!availabledOptions.contains(definition)) {
                     // fatal error : the option is not available
-                    addError(org.codelutin.i18n.I18n._("lutinutil.parser.unavailable.option", alias, start));
+                    addError(_("lutinutil.parser.unavailable.option", alias, start));
                     continue;
                 }
                 // create a OptionContext
@@ -217,7 +217,7 @@
                 if (definition.isMandatory()) {
                     int optionPos = definitionsIndex.indexOf(definition.getKey());
                     if (optionFounds[optionPos] == 0) {
-                        addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.unfound.mandatory.option", definition));
+                        addError(_("lutinutil.error.parser.unfound.mandatory.option", definition));
                     }
                 }
             }
@@ -227,25 +227,11 @@
                 int nbOccur = optionFounds[optionPos];
                 int min = context.definition.getMin();
                 if (nbOccur < min) {
-                    addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.too.less.option.found", context.definition, nbOccur, min));
+                    addError(_("lutinutil.error.parser.too.less.option.found", context.definition, nbOccur, min));
                 }
             }
         }
 
-        protected Map<OptionKey, List<Option>> instanciate() {
-            Map<OptionKey, List<Option>> acceptedOptions = new LinkedHashMap<OptionKey, List<Option>>();
-            for (OptionContext context : contexts) {
-                Option option = context.instanciate();
-                OptionKey key = parser.getOptionKey(context.definition.getKey());
-                List<Option> options = acceptedOptions.get(key);
-                if (options == null) {
-                    acceptedOptions.put(key, options = new ArrayList<Option>());
-                }
-                options.add(option);
-            }
-            return acceptedOptions;
-        }
-
         @Override
         protected void preAddSonHook(OptionContext context) {
             super.preAddSonHook(context);
@@ -282,6 +268,10 @@
                 pos++;
             }
         }
+
+        public List<Integer> getUnusedArguments() {
+            return unusedArguments;
+        }
     }
 
     /** @author tony */
@@ -331,7 +321,7 @@
                 // always check if there is at least one group available
                 if (availabledGroups.isEmpty()) {
                     // fatal error: no more args to treate for this option
-                    addError(org.codelutin.i18n.I18n._("lutinutil.parser.unavailable.option.argument", alias, argument, commandLinePosition + 1 + i));
+                    addError(_("lutinutil.parser.unavailable.option.argument", alias, argument, commandLinePosition + 1 + i));
                     break;
                 }
                 ArgumentContext argumentContext = detectArgument(argument, i);
@@ -350,7 +340,7 @@
                     int nbGroupOccurs = groupFounds[groupPos];
                     if (nbGroupOccurs == 0) {
                         // can not accept this option miss a mandatory group
-                        addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.unfound.mandatory.group", groupDefinition, definition));
+                        addError(_("lutinutil.error.parser.unfound.mandatory.group", groupDefinition, definition));
                     }
                 }
             }
@@ -363,7 +353,7 @@
             // check value not null
             if (value == null) {
                 // fatal error
-                addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.convertor", context.argument, context.definition.getValueType()));
+                addError(_("lutinutil.error.parser.convertor", context.argument, context.definition.getValueType()));
             }
         }
 
@@ -403,15 +393,12 @@
                     args.add(argumentContext.instanciate());
                 }
                 OptionKey<? extends Option, ? extends OptionParser, ? extends OptionAction> key = parser.getOptionKey(definition.getKey());
-                Option result;
-                result = key.newOption(alias, args);
-                return result;
+                return key.addOption(alias, args);
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
 
-
         /**
          * Detect the matching argument parser for given argument and position.
          * <p/>
@@ -432,7 +419,7 @@
                 result = detectArgument(lastGroup, lastArgument, argument, pos);
 
                 if (CardinalityHelper.isMandatory(lastArgument.getMin()) && result == null) {
-                    addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.unfound.mandatory.argument", lastArgument, lastGroup, argument));
+                    addError(_("lutinutil.error.parser.unfound.mandatory.argument", lastArgument, lastGroup, argument));
                     return null;
                 }
                 // the lastGroup is no more available
@@ -448,7 +435,7 @@
                 // must match the argument in this group
                 result = detectArgument(group, argument, pos);
                 if (result == null) {
-                    addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.unfound.mandatory.group", group, argument));
+                    addError(_("lutinutil.error.parser.unfound.mandatory.group", group, argument));
                 }
                 return result;
             }
@@ -534,7 +521,7 @@
                 log.info(argument + " : " + result);
                 if (result == null) {
                     //fatal error : unknown namedAndValued argument
-                    addError(org.codelutin.i18n.I18n._("lutinutil.error.parser.valued.argument.unfound", key, Arrays.asList(currentGroup)));
+                    addError(_("lutinutil.error.parser.valued.argument.unfound", key, Arrays.asList(currentGroup)));
                     return null;
                 }
                 return result;