Index: lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java
diff -u lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java:1.4 lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java:1.5
--- lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java:1.4	Wed Nov 28 19:57:12 2007
+++ lutinutil/src/java/org/codelutin/util/OptionArgumentDefinition.java	Sun Dec  2 05:12:38 2007
@@ -12,7 +12,7 @@
  */
 package org.codelutin.util;
 
-import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentDefinitionA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentA;
 
 /**
  * Cette classe représente la définition d'un argument d'une option.
@@ -25,8 +25,6 @@
  * de la constante elle même, pour un ValuedArgument de sa description et
  * pour un NamedValuedArgument de sa clef).</li>
  * <li> sa cardinalité {@link #min} {@link #max}</li>
- * <li>sa position {@link #pos} (si argument dans un groupe
- * d'arguments obligatoires) , sinon -1</li>
  * </ul>
  * De manière générale cette classe ne doit pas être instanciée directement,
  * cela est fait automatiquement lors du parsing de la définition de l'option
@@ -39,8 +37,6 @@
  */
 public class OptionArgumentDefinition {
 
-    public static final int OPTIONAL_POSITION = -1;
-
     /** type de l'argument */
     protected OptionArgumentType type;
 
@@ -56,28 +52,23 @@
     /** nombre maximum d'occurrences requis, ou -1 si pas de limite */
     protected int max;
 
-    /** la position de l'argument dans l'option si obligatoire, -1 sinon */
-    protected int pos;
-
     protected OptionArgumentDefinition(OptionArgumentType type,
                                        OptionArgumentValueType valueType,
                                        String key,
-                                       int min, int max, int pos) {
+                                       int min, int max) {
         this.type = type;
         this.valueType = valueType;
         this.key = key;
         this.min = min;
         this.max = max;
-        this.pos = pos;
     }
 
-    public OptionArgumentDefinition(OptionArgumentDefinitionA definition) {
+    public OptionArgumentDefinition(OptionArgumentA definition) {
         this.type = definition.type();
         this.valueType = definition.valueType();
         this.key = definition.key();
         this.min = definition.min();
         this.max = definition.max();
-        this.pos = definition.pos();
     }
 
     public OptionArgumentType getType() {
@@ -100,14 +91,6 @@
         return min;
     }
 
-    public int getPos() {
-        return pos;
-    }
-
-    public boolean isMandatory() {
-        return pos != OPTIONAL_POSITION;
-    }
-
     @Override
     public boolean equals(Object o) {
         if (this == o) {
@@ -131,9 +114,18 @@
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
-        StringBuffer s = new StringBuffer();
-        s.append("key:").append(key).append(", type:").append(type).append(", valueType:").append(valueType);
-        StringUtil.printCardinalite(sb, s.toString(), min, max, isMandatory());
+        StringBuffer s = new StringBuffer(key);
+        switch (type) {
+            case constant:
+                break;
+            case namedAndValued:
+                s.append('=').append(valueType.name().substring(1));
+                break;
+            case valued:
+                s.append(':').append(valueType.name().substring(1));
+                break;
+        }
+        StringUtil.printCardinalite(sb, s.toString(), min, max, min>0,"","","","");
         return sb.toString();
     }
 

Index: lutinutil/src/java/org/codelutin/util/OptionDefinition.java
diff -u lutinutil/src/java/org/codelutin/util/OptionDefinition.java:1.5 lutinutil/src/java/org/codelutin/util/OptionDefinition.java:1.6
--- lutinutil/src/java/org/codelutin/util/OptionDefinition.java:1.5	Thu Nov 29 22:23:53 2007
+++ lutinutil/src/java/org/codelutin/util/OptionDefinition.java	Sun Dec  2 05:12:38 2007
@@ -13,27 +13,22 @@
 
 package org.codelutin.util;
 
-import static org.codelutin.i18n.I18n._;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentDefinitionA;
-import org.codelutin.util.OptionParserAnnotationHelper.OptionDefinitionA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionGroupArgumentA;
 
 import java.io.IOException;
 import java.io.Writer;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
 
 /**
  * Classe qui représente la définition d'une option.
  * <p/>
  * Une option est définition par :
  * <ul>
- * <li>un nom {@link #name} qui doit être unique (il s'agit d'un identifiant interne)</li>
+ * <li>un nom {@link #key} qui doit être unique (il s'agit d'un identifiant interne)</li>
  * <li>un ensemble d'alias {@link #alias} (--option-o,...) qui commencent tous par un '-'</li>
  * <li>une description {@link #description}</li>
- * <li>une definition {@link #definition}</li>
  * <li>une cardinalité {@link #min} {@link #max}</li>
- * <li>un ensemble d'arguments obligatoires ou non  {@link #arguments}</li>
+ * <li>un ensemble de groupes d'arguments {@link #groups}</li>
  * </ul>
  *
  * @author chemit
@@ -44,46 +39,41 @@
 public class OptionDefinition {// OptionDefinition
 
     /** Le nom de cette option */
-    protected String name;
+    protected String key;
 
     /** Description of the argument */
     protected String description;
 
     /** la définition normalisée de l'option */
-    protected String definition;
+    //protected String definition;
 
-    /** Tous les alias acceptés pour cette option : -o --option,... */
+    /** les alias acceptés pour cette option : -o --option,... */
     protected String[] alias;
-    /**
-     * le nombre de fois minimum que l'option peut-être répétée sur la ligne de
-     * commande : par défaut 0 (option non obligatoire)
-     */
+
+    /** nombre minimum d'occurrences requis */
     protected int min;
 
-    /**
-     * le nombre de fois maximum que l'option peut-être répétée sur la ligne de
-     * commande: 1 par defaut (-1) pour pas de max
-     */
+    /** nombre maximum d'occurrences requis, ou -1 si pas de limite */
     protected int max;
 
-    /** la liste de tous les argument possibles */
-    protected OptionArgumentDefinition[] arguments;
+    /** les groupes d'arguments de l'option */
+    protected OptionGroupArgumentDefinition[] groups;
 
     /** la classe d'implentation de l'option */
     protected Class<? extends Option> impl;
 
-    public OptionDefinition(OptionDefinitionA anno) {
-        this.name = anno.key();
-        this.definition = anno.definition();
+    public OptionDefinition(OptionA anno) {
+        this.key = anno.key();
+        //this.definition = anno.definition();
         this.description = anno.description();
         this.min = anno.min();
         this.max = anno.max();
         this.alias = anno.alias();
-        this.impl=anno.impl();
-        OptionArgumentDefinitionA[] argumentDefinitions = anno.arguments();
-        this.arguments = new OptionArgumentDefinition[argumentDefinitions.length];
-        for (int i = 0; i < argumentDefinitions.length; i++) {
-            this.arguments[i] = new OptionArgumentDefinition(argumentDefinitions[i]);
+        this.impl = anno.impl();
+        OptionGroupArgumentA[] groups = anno.groups();
+        this.groups = new OptionGroupArgumentDefinition[groups.length];
+        for (int i = 0; i < groups.length; i++) {
+            this.groups[i] = new OptionGroupArgumentDefinition(groups[i]);
         }
     }
 
@@ -91,124 +81,107 @@
      * Pour construire une définition d'option en connaissant à l'avance
      * la définition de tous ses arguments.
      *
-     * @param name        le nom de l'option
+     * @param key         le nom de l'option
      * @param description la description de l'option
-     * @param definition  la représentation normalisée de l'option
      * @param min         le nombre d'occurrences minimum à respecter
      * @param max         le nombre maximum d'occurrences à respecter
      * @param alias       les alias de l'option
+     * @param impl        implentation de l'option
      * @param arguments   les definitions d'arguments possibles pour l'option
      */
-    public OptionDefinition(String name, String description, String definition,
-                            int min, int max, String[] alias,
-                            OptionArgumentDefinition[] arguments) {
-        this.name = name;
+    public OptionDefinition(String key, String description,
+                            int min, int max, String[] alias, Class<? extends Option> impl,
+                            OptionGroupArgumentDefinition[] arguments) {
+        this.key = key;
         this.description = description.trim();
-        this.definition = definition.trim();
         this.min = min;
         this.max = max;
+        this.impl = impl;
         this.alias = alias;
-        this.arguments = arguments;
+        this.groups = arguments;
     }
 
+
+    /*public String getDefinition() {
+        return definition;
+    }*/
+
     public String getDescription() {
         return description;
     }
 
     public int getMin() {
-        return this.min;
+        return min;
     }
 
     public int getMax() {
-        return this.max;
+        return max;
     }
 
-    public String getName() {
-        return name;
+    public String getKey() {
+        return key;
     }
 
     public String[] getAlias() {
         return alias;
     }
 
-    public String getDefinition() {
-        return definition;
-    }
-
     public Class<? extends Option> getImpl() {
         return impl;
     }
 
-    public OptionArgumentDefinition[] getArguments() {
-        return arguments == null ? new OptionArgumentDefinition[0] : arguments;
+    public OptionGroupArgumentDefinition[] getGroups() {
+        return groups == null ? new OptionGroupArgumentDefinition[0] : groups;
     }
 
-    public void printUsage(Writer writer) throws IOException {
-        writer.append(definition).append("\n    ").append(description).append("\n\n");
+    public boolean isMandatory() {
+        return min > 0;
     }
 
-    public void printDetail(Writer writer) throws IOException {
-
-        String csq = _("lutinutil.parserdef.printDetail.head", definition,
-                description,
-                String.valueOf((arguments == null ? 0 : arguments.length)),
-                String.valueOf(getNbGroups()));
-
-        writer.append(csq);
-
-        if (arguments != null) {
-            List<String> listGroup = new ArrayList<String>();
-            int currentGroup = -2;
-            boolean mandatoryGroup = false;
-            for (int i = 0, j = arguments.length; i < j; i++) {
-                OptionArgumentDefinition argument = arguments[i];
-
-                if (currentGroup == -2 || argument.getPos() != currentGroup) {
-                    // new group found
-
-                    // save old group (if not empty only)
-                    printGroupDetail(writer, listGroup, currentGroup, mandatoryGroup);
-
-                    currentGroup = argument.getPos();
-                    mandatoryGroup = currentGroup > -1;
-                }
-                listGroup.add(_("lutinutil.parserdef.printDetail.argument.head", i + 1, j, argument));
-            }
-
-            // save old group (if not empty only)
-            printGroupDetail(writer, listGroup, currentGroup, mandatoryGroup);
-
-        }
+    public void printUsage(Writer writer) throws IOException {
+        writer.append(toString()).append("\n    ").append(description).append("\n\n");
     }
 
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();
-        StringBuffer sb = new StringBuffer(name);
-        sb.append(' ').append(Arrays.toString(alias));
-        StringUtil.printCardinalite(builder, sb.toString(), min, max, min > 0);
+        StringBuffer sb = new StringBuffer();
+        for (String alia : alias) {
+            sb.append('|').append(alia);
+        }
+        String s1 = sb.toString().substring(1);
+        if (min == 0 && max == 1) {
+            StringUtil.printCardinalite(builder, s1, min, max, isMandatory(), "", "", "", "");
+        } else {
+            StringUtil.printCardinalite(builder, s1, min, max, isMandatory(), "(", ")", "[", "]");
+        }
+        if (groups.length > 0) {
+            for (OptionGroupArgumentDefinition group : groups) {
+                builder.append(' ').append(group);
+            }
+        }
         return builder.toString();
     }
 
     @Override
     public boolean equals(Object o) {
         return this == o || !(o == null || getClass() != o.getClass()) &&
-                name.equals(((OptionDefinition) o).name);
+                key.equals(((OptionDefinition) o).key);
     }
 
     @Override
     public int hashCode() {
-        return name.hashCode();
+        return key.hashCode();
     }
 
     @Override
     protected void finalize() throws Throwable {
         super.finalize();
-        if (arguments != null) {
-            for (int i = 0; i < arguments.length; i++) {
-                arguments[i] = null;
+        if (groups != null) {
+            for (int i = 0; i < groups.length; i++) {
+                groups[i] = null;
             }
-            arguments = null;
+            groups = null;
         }
         if (alias != null) {
             for (int i = 0; i < alias.length; i++) {
@@ -217,39 +190,4 @@
             alias = null;
         }
     }
-
-    protected int getNbGroups() {
-        if (arguments == null) {
-            return 0;
-        }
-        List<Integer> list = new ArrayList<Integer>();
-        for (OptionArgumentDefinition argument : arguments) {
-            if (!list.contains(argument.getPos())) {
-                list.add(argument.getPos());
-            }
-        }
-        int result = list.size();
-        list.clear();
-        return result;
-    }
-
-    private void printGroupDetail(Writer writer, List<String> list,
-                                  int currentGroup, boolean mandatoryGroup)
-            throws IOException {
-        if (list.isEmpty()) {
-            // nothing to do here
-            return;
-        }
-        String txt;
-        if (mandatoryGroup) {
-            txt = _("lutinutil.parserdef.printDetail.group.mandatory", currentGroup, list.size());
-        } else {
-            txt = _("lutinutil.parserdef.printDetail.group.optional", list.size());
-        }
-        writer.append(txt);
-        for (String s : list) {
-            writer.append(s);
-        }
-        list.clear();
-    }
 }// OptionDefinition