Index: lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java
diff -u /dev/null lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java:1.1
--- /dev/null	Mon Nov 19 19:06:06 2007
+++ lutinutil/src/java/org/codelutin/util/OptionArgumentValueType.java	Mon Nov 19 19:05:58 2007
@@ -0,0 +1,168 @@
+package org.codelutin.util;
+
+import java.io.File;
+import static java.lang.Boolean.FALSE;
+import static java.lang.Boolean.TRUE;
+
+/**
+ * le type de la valeur d'un argument d'option.
+ * <p/>
+ * La classe offre deux méthodes statiques publiques pour trouver un tel type :
+ * <p/>
+ * {@link #findTypeFromDefinition(String)} pour trouver un type à partir d'un
+ * type détecté dans la définition d'un argument.
+ * <p/>
+ * {@link #findTypeFromArgument(String)} pour trouver un type à partir d'un
+ * argument de la ligne de commande.
+ * <p/>
+ * * Chaque constante offre deux méthodes publiques :
+ * <p/>
+ * {@link #matchType(String)} pour détecter si la valeur d'un argument de la
+ * ligne de commande correspond à un type.
+ * <p/>
+ * * {@link #getClazz()} } pour retourner la class d'implantation du type.
+ *
+ * @author chemit
+ */
+public enum OptionArgumentValueType {
+    /**
+     * Argument de type boolean.
+     * <p/>
+     * Valeurs autorisées : false|true
+     */
+    _boolean(Boolean.class) {
+        public boolean matchType(String arg) {
+            return super.matchType(arg) &&
+                    (arg.equalsIgnoreCase(FALSE.toString()) ||
+                            arg.equalsIgnoreCase(TRUE.toString()));
+        }
+    },
+    /**
+     * Argument de type entier.
+     * <p/>
+     * Valeurs autorisées  : tout {@link java.lang.Long}
+     */
+    _integer(Integer.class) {
+        public boolean matchType(String arg) {
+            return super.matchType(arg) && arg.matches("[0-9]+");
+        }
+    },
+    /**
+     * Argument de type decimale.
+     * <p/>
+     * Valeurs autorisées  : tout {@link java.lang.Double}
+     */
+    _float(Double.class) {
+        public boolean matchType(String arg) {
+            return super.matchType(arg) && arg.matches("[0-9]+\\.[0-9]+");
+        }
+    },
+    /**
+     * Argument de type class.
+     * <p/>
+     * Valeurs autorisées  : tout nom complet de classe (existante ou non)
+     */
+    _class(Class.class) {
+        public boolean matchType(String arg) {
+            if (!super.matchType(arg)) {
+                return false;
+            }
+            try {
+                Class.forName(arg);
+                return true;
+            } catch (ClassNotFoundException e) {
+                //  on essaye quand même de matcher une classe par sa syntaxe ?
+                return arg.matches("(\\w+\\.)+[A-Z]\\w+");
+            }
+        }
+    },
+    /**
+     * Argument de type fichier existant.
+     * <p/>
+     * Valeurs autorisées  : tout fichier <b>existant</b>
+     */
+    _file(File.class) {
+        public boolean matchType(String arg) {
+            return super.matchType(arg) && new File(arg).exists();
+        }
+    },
+    /**
+     * Argument de type fichier.
+     * <p/>
+     * Valeurs autorisées  : tout fichier (existant, ou non)
+     */
+    _newfile(File.class) {
+        public boolean matchType(String arg) {
+            //TODO Find a way to distinguish this from _string...
+            return super.matchType(arg);
+        }
+    },
+
+    /**
+     * Argument de type string.
+     * <p/>
+     * Valeurs autorisées  : tout! (sauf chaine vide)
+     */
+    _string(String.class);
+
+    /**
+     * Cherche un type de valeur d'argument à partir d'un type détecté dans la
+     * définition d'un argument de manière laxiste :
+     * <p/>
+     * la nom du type n'est pas case sensitive, il peut être entouré d'espace.
+     * <p/>
+     * Par contre il ne peut pas être vide ou null.
+     *
+     * @param type le type de valeur recherché
+     * @return le type trouvé ou null si n'existe pas
+     */
+    public static OptionArgumentValueType findTypeFromDefinition(String type) {
+        // on effectue ici un controle
+        if (type == null || type.isEmpty() || (type = type.trim()).isEmpty()) {
+            return null;
+        }
+        String tmp = "_" + type.toLowerCase();
+        for (OptionArgumentValueType valueType : values()) {
+            if (valueType.name().equals(tmp)) {
+                return valueType;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Cherche un type de valeur d'argument à partir d'un argument de
+     * la ligne de commande :
+     *
+     * @param arg le type de valeur recherché
+     * @return le type trouvé ou null si n'existe pas
+     */
+    public static OptionArgumentValueType findTypeFromArgument(String arg) {
+        for (OptionArgumentValueType type : values()) {
+            if (type.matchType(arg)) {
+                return type;
+            }
+        }
+        return null;
+    }
+
+    /** @return la class d'implantation du type */
+    public Class getClazz() {
+        return clazz;
+    }
+
+    /**
+     * @param arg l'argument dont on veut tester le type
+     * @return <code>true</code> si l'arg donné est du bon type
+     */
+    public boolean matchType(String arg) {
+        return arg != null && !arg.isEmpty();
+    }
+
+    /** la classe d'implantation du type */
+    private final Class clazz;
+
+    OptionArgumentValueType(Class clazz) {
+        this.clazz = clazz;
+    }
+}