Index: lutinutil/src/java/org/codelutin/util/OptionDefinitionFactory.java
diff -u /dev/null lutinutil/src/java/org/codelutin/util/OptionDefinitionFactory.java:1.1
--- /dev/null	Mon Nov 19 19:53:35 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinitionFactory.java	Mon Nov 19 19:53:30 2007
@@ -0,0 +1,180 @@
+package org.codelutin.util;
+
+import org.apache.commons.collections.map.ReferenceMap;
+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;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Factory de définitions d'options.
+ * <p/>
+ * Cette classe servira de super classe à la Factory generee par le parseur
+ * de définition, la genetation consiste a implanter la methode init pour
+ * initialiser la map d'option.
+ * <p/>
+ * Elle contient une méthode pour récupérer une factory initialisée à partir
+ * de sa classe {@link #newFactory(Class)}.
+ *
+ * @author chemit
+ */
+
+public abstract class OptionDefinitionFactory {
+
+    /**
+     * @param clazz class of the factory to get
+     * @return an instance of the required factory, initialize.
+     * @throws InstantiationException if error while instanciate factory
+     * @throws IllegalAccessException if can not access class
+     */
+    public static OptionDefinitionFactory newFactory(
+            Class<? extends OptionDefinitionFactory> clazz)
+            throws InstantiationException, IllegalAccessException {
+
+        // instanciate the factory
+        OptionDefinitionFactory factor = clazz.newInstance();
+
+        // init factory (this is the generated method)
+        factor.init();
+
+        return factor;
+    }
+
+    /**
+     * La methode a implanter pour initialiser la factory.
+     * <p/>
+     * Il s'agit de remplir {@link #options} avec des {@link OptionDefinition}
+     */
+    public abstract void init();
+
+    /** les options enregistrees dans la factory indexees par leur nom unique */
+    protected final Map<String, OptionDefinition> options;
+
+    /** les clefs des options connues par la factory (Instanciation paresseuse). */
+    protected List<String> keys;
+
+    @SuppressWarnings("unchecked")
+    public OptionDefinitionFactory() {
+        options = (Map<String, OptionDefinition>) new ReferenceMap();
+    }
+
+    public OptionDefinition get(String key) {
+        return options.get(key);
+    }
+
+    public List<String> getKeys() {
+        if (keys == null) {
+            ArrayList<String> list = new ArrayList<String>(options.keySet());
+            Collections.sort(list);
+            keys = Collections.unmodifiableList(list);
+        }
+        return keys;
+    }
+
+    public OptionDefinition[] getOptions() {
+        return options.values().toArray(new OptionDefinition[options.size()]);
+    }
+
+    public void printUsage(Writer writer, String name) throws IOException {
+        writer.append(_("lutinutil.parserdef.printUsage.factory.head",name));
+        if (!getKeys().isEmpty()) {
+            for (String key : keys) {
+                get(key).printUsage(writer);
+            }
+        }
+    }
+
+    public void printDetails(Writer writer) throws IOException {
+        int size = getKeys().size();
+        writer.append(_("lutinutil.parserdef.printDetail.factory.head",
+                this, size));
+        for (int i = 0; i < size; i++) {
+            OptionDefinition definition = options.get(getKeys().get(i));
+            writer.append(_(LUTINUTIL_PARSERDEF_PRINT_DETAIL_OPTION_HEAD,
+                    i + 1, size, definition));
+            definition.printDetail(writer);
+        }
+    }
+
+    protected OptionDefinition addOptionDefinition(String name,
+                                                   String definition,
+                                                   String description,
+                                                   int min, int max,
+                                                   int nbArguments,
+                                                   String alias) {
+        return addOptionDefinition0(name, description, definition, min, max,
+                nbArguments, alias);
+    }
+
+    protected OptionDefinition addOptionDefinition(String name,
+                                                   String definition,
+                                                   String description,
+                                                   int min, int max,
+                                                   int nbArguments,
+                                                   String alias, String alias2) {
+        return addOptionDefinition0(name, description, definition, min, max,
+                nbArguments, alias, alias2);
+    }
+
+    protected OptionDefinition addOptionDefinition(String name,
+                                                   String definition,
+                                                   String description,
+                                                   int min, int max,
+                                                   int nbArguments,
+                                                   String alias, String alias2,
+                                                   String alias3) {
+        return addOptionDefinition0(name, description, definition, min, max,
+                nbArguments, alias, alias2, alias3);
+    }
+
+    protected OptionDefinition addOptionDefinition(String name,
+                                                   String definition,
+                                                   String description,
+                                                   int min, int max,
+                                                   int nbArguments,
+                                                   String alias, String alias2,
+                                                   String alias3, String alias4) {
+        return addOptionDefinition0(name, description, definition, min, max,
+                nbArguments, alias, alias2, alias3, alias4);
+    }
+
+    protected OptionDefinition addOptionDefinition0(String name,
+                                                    String definition,
+                                                    String description,
+                                                    int min, int max,
+                                                    int nbArguments,
+                                                    String... alias) {
+        OptionDefinition result;
+        result = new OptionDefinition(name, description, definition, min, max,
+                nbArguments, alias);
+        options.put(name, result);
+        return result;
+    }
+
+    protected OptionArgumentDefinition addArgumentDefinition(
+            OptionDefinition definition, int index, String key,
+            OptionArgumentType type,
+            OptionArgumentValueType valueType,
+            int min, int max, int position) {
+        try {
+            OptionArgumentDefinition result;
+            result = new OptionArgumentDefinition(type, valueType, key, min,
+                    max, position);
+            definition.arguments[index] = result;
+            return result;
+        } catch (IllegalArgumentException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        options.clear();
+    }
+}