Index: lutinutil/src/java/org/codelutin/util/CategorisedListenerSet.java
diff -u lutinutil/src/java/org/codelutin/util/CategorisedListenerSet.java:1.7 lutinutil/src/java/org/codelutin/util/CategorisedListenerSet.java:1.8
--- lutinutil/src/java/org/codelutin/util/CategorisedListenerSet.java:1.7	Wed Jan  4 13:26:32 2006
+++ lutinutil/src/java/org/codelutin/util/CategorisedListenerSet.java	Wed Sep 13 13:26:42 2006
@@ -23,9 +23,9 @@
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
  * Copyright Code Lutin
- * @version $Revision: 1.7 $
+ * @version $Revision: 1.8 $
  *
- * Mise a jour: $Date: 2006/01/04 13:26:32 $
+ * Mise a jour: $Date: 2006/09/13 13:26:42 $
  * par : $Author: bpoussin $
  */
 
@@ -35,6 +35,10 @@
 import java.util.Iterator;
 import java.util.WeakHashMap;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.codelutin.log.LutinLogFactory;
+
 /**
 * Objet permettant de géré plusieurs liste de listener de facon simple.
 * Chaque liste de listener est rangé en fonction d'une cle (categorie)
@@ -53,7 +57,10 @@
 * 
 * @see org.codelutin.util.ListenerSet
 */
-public class CategorisedListenerSet { // CategorisedListenerSet
+public class CategorisedListenerSet<Listener> { // CategorisedListenerSet
+
+    /** to use log facility, just put in your code: log.info(\"...\"); */
+    static private Log log = LogFactory.getLog(CategorisedListenerSet.class);
 
     /**
     * permet de remplacer toutes les categories.
@@ -65,10 +72,10 @@
     /** HashMap de ListenerSet, en cle l'objet qui caracterise la categorie
     * en valeur un ListenerSet
     */
-    protected WeakHashMap listeners = new WeakHashMap();
-    protected WeakHashMap categoryParent = new WeakHashMap();
+    protected WeakHashMap<Object, ListenerSet<Listener>> listeners = new WeakHashMap<Object, ListenerSet<Listener>>();
+    protected WeakHashMap<Object, Object> categoryParent = new WeakHashMap<Object, Object>();
     protected boolean isClassCategory = true;
-    protected Class listenerClass = null;
+//    protected Class listenerClass = null;
 
     /**
      * Construit un CategorisedListenerSet qui accepte n'importe quel type
@@ -77,13 +84,14 @@
      */
     public CategorisedListenerSet(){}
 
-    /**
-    * Construit un CategorisedListenerSet qui accepte les listeners 
-    * dont le type est passé en parametre et dont le isClassCategory est activé 
-    */
-    public CategorisedListenerSet(Class listenerClass){
-        this.listenerClass = listenerClass;
-    }
+//    /**
+//    * Construit un CategorisedListenerSet qui accepte les listeners 
+//    * dont le type est passé en parametre et dont le isClassCategory est activé 
+//    */
+//    public CategorisedListenerSet(Class listenerClass){
+//        this.listenerClass = listenerClass;
+//    }
+    
     /**
      * 
      * @param listenerClass la classe dont doit heriter les listeners pour
@@ -94,7 +102,7 @@
      * interfaces) 
      */
     public CategorisedListenerSet(Class listenerClass, boolean isClassCategory) {
-        this(listenerClass);
+//        this(listenerClass);
         this.isClassCategory = isClassCategory;
     }
 
@@ -124,9 +132,9 @@
     * @param category la categorie dans lequel il faut ajouter le listener
     * @param l le listener a ajouter
     */
-    public void add(Object category, Object l){
+    public void add(Object category, Listener l){
         checkCategory(category);
-        ListenerSet listeners = getListeners(category);
+        ListenerSet<Listener> listeners = getListeners(category);
         listeners.add(l);
     }
     /**
@@ -135,8 +143,8 @@
     * @param category la categorie dans lequel il faut supprimer le listener
     * @param l le listener a supprimer
     */
-    public void remove(Object category, Object l){
-        ListenerSet listeners = getListeners(category);
+    public void remove(Object category, Listener l){
+        ListenerSet<Listener> listeners = getListeners(category);
         listeners.remove(l);
     }
     /**
@@ -149,8 +157,11 @@
     */
     public void fire(Object category, String methodName, Object event)
             throws Exception {
-        Log.logDevFinest("org.codelutin.util.CategorisedListenerSet.fire", "fire category: " + category + " method: " + methodName);
-        getAllListeners(category).fire(methodName, event);
+        if (log.isTraceEnabled()) {
+            log.trace("fire category: " + category + " method: " + methodName);
+        }
+        ListenerSet<Listener> ls = getAllListeners(category);
+        ls.fire(methodName, event);
 /*        for(Iterator i=iterator(category); i.hasNext();){
             Object o = i.next();
             Log.logDevFinest("org.codelutin.util.CategorisedListenerSet.fire", "fire on: " + o);
@@ -167,9 +178,8 @@
     * @param methodeName le nom de la méthode de la classe listener
     */
     public void fire(Object category, String methodName) throws Exception {
-        for(Iterator i=iterator(category); i.hasNext();){
-            Object o = i.next();
-            Statement stm  = new Statement(o, methodName, null);
+        for(Listener l : getAllListeners(category)){
+            Statement stm  = new Statement(l, methodName, null);
             stm.execute();
         }
     }
@@ -178,7 +188,7 @@
     * souhaite prevenir une certaine categorie. Ceci inclue les ancetre de la
     * categorie
     */
-    public Iterator iterator(Object category){
+    public Iterator<Listener> iterator(Object category){
         return getAllListeners(category).iterator();
     }
 
@@ -186,11 +196,11 @@
     * Retourne un ListenerSet contenant tous les listeners c'est à dire les
     * listener de la categorie demandé mais aussi les listeners des ancetres
     */
-    protected ListenerSet getAllListeners(Object category){
-        ListenerSet result = new ListenerSet(listenerClass);
+    protected ListenerSet<Listener> getAllListeners(Object category){
+        ListenerSet<Listener> result = new ListenerSet<Listener>();
         if(category == ALL){
-            for(Iterator i=listeners.values().iterator(); i.hasNext();){
-                result.addAll((ListenerSet)i.next());
+            for(ListenerSet<Listener> ls : listeners.values()){
+                result.addAll(ls);
             }
         }else{
             Object parentCategory = category;
@@ -202,12 +212,14 @@
                 parentCategory = categoryParent.get(parentCategory);
             }
         }
-        Log.logDevFinest("org.codelutin.util.CategorisedListenerSet.getListeners", "getAllListeners category: " + category + " result: " + result);
+        if (log.isTraceEnabled()) {
+            log.trace("getAllListeners category: " + category + " result: " + result);
+        }
         return result;
     }
 
-    protected ListenerSet getListenersClass(Class category) {
-        ListenerSet result = new ListenerSet(listenerClass);
+    protected ListenerSet<Listener> getListenersClass(Class category) {
+        ListenerSet<Listener> result = new ListenerSet<Listener>();
         Class superClass = category.getSuperclass();
         if (superClass != null) {
             result.addAll(getAllListeners(superClass));
@@ -222,17 +234,19 @@
     * Retourne un ListenerSet contenant seulement les listener de la categorie
     * demandé. Si la categorie n'existe pas alors elle est créé.
     */
-    protected ListenerSet getListeners(Object category){
-        ListenerSet result = (ListenerSet)listeners.get(category);
+    protected ListenerSet<Listener> getListeners(Object category){
+        ListenerSet<Listener> result = listeners.get(category);
         if(result == null){
-            listeners.put(category, result = new ListenerSet(listenerClass));
+            listeners.put(category, result = new ListenerSet<Listener>());
+        }
+        if (log.isTraceEnabled()) {
+            log.trace("getListeners category: " + category + " result: " + result);
         }
-        Log.logDevFinest("org.codelutin.util.CategorisedListenerSet.getListeners", "getListeners category: " + category + " result: " + result);
         return result;
     }
 
     public String toString(){
-        return "Listener class:" + listenerClass + "\nCategory: " + categoryParent + "\nListener: " + listeners;
+        return "Listeners Category: " + categoryParent + "\nListener: " + listeners;
     }
 
 } // CategorisedListenerSet

Index: lutinutil/src/java/org/codelutin/util/ListenerSet.java
diff -u lutinutil/src/java/org/codelutin/util/ListenerSet.java:1.8 lutinutil/src/java/org/codelutin/util/ListenerSet.java:1.9
--- lutinutil/src/java/org/codelutin/util/ListenerSet.java:1.8	Tue Aug 22 15:38:32 2006
+++ lutinutil/src/java/org/codelutin/util/ListenerSet.java	Wed Sep 13 13:26:42 2006
@@ -22,9 +22,9 @@
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
  * Copyright Code Lutin
- * @version $Revision: 1.8 $
+ * @version $Revision: 1.9 $
  *
- * Mise a jour: $Date: 2006/08/22 15:38:32 $
+ * Mise a jour: $Date: 2006/09/13 13:26:42 $
  * par : $Author: bpoussin $
  */
 package org.codelutin.util;
@@ -66,25 +66,25 @@
  *
  * @see   org.codelutin.util.CategorisedListenerSet
  */
-public class ListenerSet<T> implements Iterable<T> { // ListenerSet
+public class ListenerSet<Listerner> implements Iterable<Listerner> { // ListenerSet
 
     /** DOCUMENTME Description of the Field */
-    protected Class<T> listenerClass  = null;
+//    protected Class<T> listenerClass  = null;
     /** DOCUMENTME Description of the Field */
-    protected HashSet<Reference<T>> listeners    = new HashSet<Reference<T>>();
+    protected HashSet<Reference<Listerner>> listeners    = new HashSet<Reference<Listerner>>();
 
     /** DOCUMENTME Constructor for the ListenerSet object */
     public ListenerSet() { }
 
-    /**
-     * Constructeur permettant de passer une classe que devra s'attisfaire les
-     * listener que l'on souhaite ajouter
-     *
-     * @param listenerClass  DOCUMENTME Description of the Parameter
-     */
-    public ListenerSet(Class<T> listenerClass) {
-        this.listenerClass = listenerClass;
-    }
+//    /**
+//     * Constructeur permettant de passer une classe que devra s'attisfaire les
+//     * listener que l'on souhaite ajouter
+//     *
+//     * @param listenerClass  DOCUMENTME Description of the Parameter
+//     */
+//    public ListenerSet(Class<T> listenerClass) {
+//        this.listenerClass = listenerClass;
+//    }
 
     public int size() {
         return listeners.size();
@@ -97,18 +97,18 @@
      * si l'objet n'est pas du type passé en argument du constructeur
      * une IllegalArgumentException est levée.
      */
-    public void add(T l) {
+    public void add(Listerner l) {
         if (l == null) {
             return;
         }
-        if (listenerClass == null || listenerClass.isInstance(l)) {
-            TransparenteWeakReference<T> ref  = new TransparenteWeakReference<T>(l);
+//        if (listenerClass == null || listenerClass.isInstance(l)) {
+            TransparenteWeakReference<Listerner> ref  = new TransparenteWeakReference<Listerner>(l);
             listeners.add(ref);
-        } else {
-            throw new IllegalArgumentException("Listener object ("
-                     + l.getClass().getName() + ") is not compatible with class: "
-                     + listenerClass.getName());
-        }
+//        } else {
+//            throw new IllegalArgumentException("Listener object ("
+//                     + l.getClass().getName() + ") is not compatible with class: "
+//                     + listenerClass.getName());
+//        }
     }
 
     /**
@@ -116,15 +116,15 @@
      *
      * @param ls  The feature to be added to the All attribute
      */
-    public void addAll(ListenerSet<T> ls) {
-        if (listenerClass == null || (ls.listenerClass != null &&
-                listenerClass.isAssignableFrom(ls.listenerClass))) {
+    public void addAll(ListenerSet<Listerner> ls) {
+//        if (listenerClass == null || (ls.listenerClass != null &&
+//                listenerClass.isAssignableFrom(ls.listenerClass))) {
             listeners.addAll(ls.listeners);
-        } else {
-            throw new IllegalArgumentException("Listener object ("
-                     + ls.listenerClass + ") is not compatible with : "
-                     + listenerClass);
-        }
+//        } else {
+//            throw new IllegalArgumentException("Listener object ("
+//                     + ls.listenerClass + ") is not compatible with : "
+//                     + listenerClass);
+//        }
     }
 
     /**
@@ -165,8 +165,8 @@
      *
      * @return   DOCUMENTME Description of the Return Value
      */
-    public Iterator<T> iterator() {
-        return new ReferenceIterator<T>(listeners.iterator());
+    public Iterator<Listerner> iterator() {
+        return new ReferenceIterator<Listerner>(listeners.iterator());
     }
 
     /**
@@ -174,8 +174,8 @@
      *
      * @param l  DOCUMENTME Description of the Parameter
      */
-    public void remove(T l) {
-        TransparenteWeakReference<T> ref  = new TransparenteWeakReference<T>(l);
+    public void remove(Listerner l) {
+        TransparenteWeakReference<Listerner> ref  = new TransparenteWeakReference<Listerner>(l);
         listeners.remove(ref);
     }