Index: lutinutil/src/java/org/codelutin/util/OptionArgumentType.java
diff -u /dev/null lutinutil/src/java/org/codelutin/util/OptionArgumentType.java:1.1
--- /dev/null	Mon Nov 19 19:05:22 2007
+++ lutinutil/src/java/org/codelutin/util/OptionArgumentType.java	Mon Nov 19 19:05:12 2007
@@ -0,0 +1,163 @@
+package org.codelutin.util;
+
+import static org.codelutin.util.OptionArgumentValueType._string;
+
+/**
+ * le type d'un argument d'option.
+ * <p/>
+ * La classe offre une méthode publique statique :
+ * <p/>
+ * {@link #findType(String)} pour trouver un type à partir de la
+ * définition d'un argument.
+ * <p/>
+ * Chaque constante offre deux méthodes publiques :
+ * <p/>
+ * {@link #explodeDefinition(String)} pour obtenir le couple
+ * [clef d'argument, type d'argument] à partir de la définition
+ * d'un argument.
+ * <p/>
+ * {@link #extractArgumentValue(String)} pour obtenir la valeur d'un
+ * argument de la ligne de commande.
+ *
+ * @author chemit
+ */
+public enum OptionArgumentType {
+    /**
+     * Dans la définition d'un argument , ce type est représenté sous la forme
+     * <p/>
+     * <center><b><code>constantKey</code></b></center>
+     * <p/>
+     * <p/>
+     * La clef d'un tel argument est <code>constantKey</code>.
+     * <p/>
+     * Son type est toujours {@link OptionArgumentValueType#_string}.
+     * <p/>
+     * Pour accepter cet argument de la ligne de commande, il faut entrer
+     * extactement <code>constantKey</code>.
+     *
+     * @see OptionArgumentValueType#matchType(String)
+     * @see OptionArgumentValueType#findTypeFromDefinition(String)
+     * @see OptionArgumentValueType#findTypeFromArgument(String)
+     */
+    constant() {
+        public String[] explodeDefinition(String argumentDefinition) {
+            return new String[]{argumentDefinition, _string.toString()};
+        }
+        public String extractArgumentValue(String argument) {
+            return argument;
+        }
+    },
+    /**
+     * Dans la définition d'un argument , ce type est représenté sous la forme
+     * <p/>
+     * <center><b><code>valuedKey:type</code></b></center>
+     * <p/>
+     * La clef d'un tel argument est <code>valuedKey</code>.
+     * <p/>
+     * Son type est celui mappe sur <code>type</code>.
+     * <p/>
+     * Pour accepter cet argument de la ligne de commande, il faut entrer
+     * extactement un argument vérifiant le <code>type</code>.
+     *
+     * @see OptionArgumentValueType#matchType(String)
+     * @see OptionArgumentValueType#findTypeFromDefinition(String)
+     * @see OptionArgumentValueType#findTypeFromArgument(String)
+     */
+    valued() {
+        public String[] explodeDefinition(String argumentDefinition) {
+            int index = argumentDefinition.indexOf(':');
+            return new String[]{argumentDefinition.substring(0, index),
+                    argumentDefinition.substring(index + 1)};
+        }
+        public String extractArgumentValue(String argument) {
+            return argument;
+        }
+    },
+    /**
+     * Dans la définition d'un argument , ce type est représenté sous la forme
+     * <p/>
+     * <center><b><code>namedAndValuedKey=type</code></b></center>
+     * <p/>
+     * La clef d'un tel argument est <code>namedAndValuedKey</code>.
+     * <p/>
+     * Son type est celui mappe sur <code>type</code>.
+     * <p/>
+     * Pour accepter cet argument de la ligne de commande, il faut entrer
+     * extactement un argument de la forme
+     * <center><b><code>namedAndValuedKey=valeur</code></b>, où
+     * <code>type</code> doit vérifier le type mappé sur <code>type</code>
+     * </center>
+     *
+     * @see OptionArgumentValueType#matchType(String)
+     * @see OptionArgumentValueType#findTypeFromDefinition(String)
+     * @see OptionArgumentValueType#findTypeFromArgument(String)
+     */
+    namedAndValued() {
+        public String[] explodeDefinition(String argumentDefinition) {
+            int index = argumentDefinition.indexOf('=');
+            return new String[]{argumentDefinition.substring(0, index),
+                    argumentDefinition.substring(index + 1)};
+        }
+        public String extractArgumentValue(String argument) {
+            int index = argument.indexOf('=');
+            return index == -1 || index == argument.length() - 1 ? ""
+                    : argument.substring(index + 1);
+        }
+    };
+
+    /**
+     * Cherche un type de d'argument à partir d'un argument de sa définition :
+     *
+     * @param argumentDefinition le type de valeur recherché
+     * @return le type trouvé, ou null si la définition est vide.
+     */
+    public static OptionArgumentType findType(String argumentDefinition) {
+        // on effectue ici un controle
+        if (argumentDefinition == null || argumentDefinition.isEmpty() ||
+                (argumentDefinition = argumentDefinition.trim()).isEmpty()) {
+            return null;
+        }
+        if (argumentDefinition.indexOf(':') > -1) {
+            // on a un valued type
+            return valued;
+        }
+        if (argumentDefinition.indexOf('=') > -1) {
+            // on a un named valued type
+            return namedAndValued;
+        }
+        return constant;
+    }
+
+    /**
+     * Pour exploser une définition d'argument en un
+     * couple [clef argument,type argument].
+     * <p/>
+     * Pour les arguments de type {@link OptionArgumentType#constant},
+     * on retourne [argument,"_string"] puisque tous les arguments de type
+     * constant sont de type string.
+     * <p/>
+     * Pour les arguments de type {@link OptionArgumentType#valued},
+     * on retourne [clef,type] (la définition est de la forme clef:type).
+     * <p/>
+     * Pour les arguments de type {@link OptionArgumentType#namedAndValued},
+     * on retourne [clef,type] (la définition est de la forme clef=type).
+     *
+     * @param argumentDefinition la définition de l'argument
+     * @return le couple [clef,type] trouvé à partir de la définition
+     */
+    public abstract String[] explodeDefinition(String argumentDefinition);
+
+    /**
+     * Extrait d'un argument de la ligne de commande, la valeur de l'argument.
+     * <p/>
+     * Pour les arguments de type {@link OptionArgumentType#constant} et
+     * {@link OptionArgumentType#valued}, il s'agit de tout l'argument, alors
+     * que pour le type {@link OptionArgumentType#namedAndValued}, il s'agit de
+     * ce qui suit le caractère '=' dans l'argument (représenté sous la
+     * forme clef=valeur).
+     *
+     * @param argument l'argument de la ligne de commande à traiter
+     * @return la valeur extraite de l'argument
+     */
+    public abstract String extractArgumentValue(String argument);
+}