Index: lutinutil/src/java/org/codelutin/util/HashMapMultiKey.java
diff -u lutinutil/src/java/org/codelutin/util/HashMapMultiKey.java:1.5 lutinutil/src/java/org/codelutin/util/HashMapMultiKey.java:1.6
--- lutinutil/src/java/org/codelutin/util/HashMapMultiKey.java:1.5	Thu Oct 27 16:28:00 2005
+++ lutinutil/src/java/org/codelutin/util/HashMapMultiKey.java	Fri Nov 11 03:16:59 2005
@@ -23,9 +23,9 @@
  * Created: 2 nov. 2004
  *
  * @author Benjamin Poussin <poussin@codelutin.com>
- * @version $Revision: 1.5 $
+ * @version $Revision: 1.6 $
  *
- * Mise a jour: $Date: 2005/10/27 16:28:00 $
+ * Mise a jour: $Date: 2005/11/11 03:16:59 $
  * par : $Author: bpoussin $
  */
 
@@ -44,8 +44,8 @@
 
 /**
  * Permet de stocker un element suivant un ensemble de cle.
- * @TODO pour l'instant on ne gere pas les references sur les clef
- * FIXME pas le temps d'implanter toutes les methodes pour un support
+ *
+ * FIXME: pas le temps d'implanter toutes les methodes pour un support
  * complet des References. iterator(), entrySet(), ... peuvent ne pas
  * fonctionner comme il faut, c-a-d qu'il retourne les references et non
  * les objets. Mais les methodes simples fonctionnent: put, remove, get, ...
@@ -64,6 +64,7 @@
     /** key: la valeur, valeur: la cle. Permet de supprimer rapidement une
     * key lorsque la valeur disparait */
     protected HashMap valueToKey = new HashMap();
+    protected ReferenceQueue refQueueKey = new ReferenceQueue();
     protected ReferenceQueue refQueueValue = new ReferenceQueue();
 
     protected Object keyType = null;
@@ -92,17 +93,23 @@
     */
     protected void cleanQueue(){
         Reference o = null;
+        while(null != (o = refQueueKey.poll())) {
+            if(log.isTraceEnabled()){ log.trace("clean the refQueueKey : " + o);}
+            Object val = super.remove(o);
+            valueToKey.remove(val);
+        }
+
         while(null != (o = refQueueValue.poll())) {
             if(log.isTraceEnabled()){ log.trace("clean the refQueueValue : " + o);}
             // suppression dans la table des values et recuperation de la cle
             // associé
-            Object key = valueToKey.remove(o);
+            Object key = derefKey(valueToKey.remove(o));
             if( key != null) {
                 // suppression dans la table a partir de la cle recuperé
                 super.remove(key);
                 // suppression dans l'association des objets de la cle
                 for(Iterator i=((Key)key).iterator(); i.hasNext();){
-                    Set list = (Set)keys.get(i.next());
+                    Set list = getKeys(i.next());
                     if (list != null) {
                         list.remove(key);
                     }
@@ -111,8 +118,6 @@
                 if(log.isTraceEnabled()){ log.trace("key is null !!! " + o);}
             }
         }
-
-        // TODO la meme chose ici pour la queue des cles
     }
 
     /**
@@ -167,18 +172,35 @@
     * e.
     * @param e l'element que doivent contenir les cles
     * @return la liste des cles. Si aucune cle ne contient l'element e,
-    * alors la liste retourné est vide
+    * alors la liste retourné est vide.
     */
     public Set getKeys(Object e){
         cleanQueue();
         Set list = (Set)keys.get(e);
         if( list == null){
             list = new HashSet();
-            keys.put(e, list);
+        } else {
+            // on nettoie un peu la liste en supprimant les cles liberees
+            for (Iterator i=list.iterator(); i.hasNext();) {
+                if (derefKey(i.next()) == null) {
+                    i.remove();
+                }
+            }
+            if (list.size() == 0) {
+                keys.remove(e);
+            }
         }
         return list;
     }
 
+    protected Set getKeysAndAdd(Object e){
+        Set list = getKeys(e);
+        // il ne faut pas encapsuler e dans une ref, sinon on ne retrouve
+        // plus les cles si l'objet etait seulement dans la cle
+        keys.put(e, list);
+        return list;
+    }
+
     /**
     * Method put
     *
@@ -195,17 +217,18 @@
         if(key instanceof Key){
             // ajout dans la hash des cles
             Key keyObject = (Key)key;
+            Object keyRef = refKey(key);
             for(int i=0; i<keyObject.size(); i++){
                 Object k = keyObject.get(i);
                 // on recupere la liste des cles qui contiennent deja cette cle
-                Set list = getKeys(k);
-                list.add(key);
+                Set list = getKeysAndAdd(k);
+                list.add(keyRef);
             }
             // On encapsule la valeur si besoin
             value = refValue(value);
-            valueToKey.put(value, key);
+            valueToKey.put(value, keyRef);
             // reelle ajout
-            return derefValue(super.put(key, value));
+            return derefValue(super.put(keyRef, value));
         }
         throw new IllegalArgumentException("L'argument key doit etre un tableau d'objet");
     }
@@ -216,7 +239,7 @@
     }
 
     public Object get(Object key) {
-        // a chaque fois que l'on ajoute, on nettoie un peu avant
+        // a chaque fois que l'on prend, on nettoie un peu avant
         cleanQueue();
         return derefValue(super.get(key));
     }
@@ -243,7 +266,7 @@
             // de devoir le supprimer dans les lists de keys, le
             // GC le ferait pour nous.
             for(Iterator i=((Key)key).iterator(); i.hasNext();){
-                Set list = (Set)keys.get(i.next());
+                Set list = getKeys(i.next());
                 if (list != null) {
                     list.remove(key);
                 }
@@ -254,12 +277,10 @@
             return derefValue(result);
         }else{
             ArrayList result = new ArrayList();
-            // on va directement chercher dans keys et non pas en utilisant
-            // getKeys pour eviter de creer des Set pour rien
-            Set list = (Set)keys.get(key);
-            if ( list != null){
+            Set list = getKeys(key);
+            if ( list != null ){
                 for(Iterator i=list.iterator(); i.hasNext();){
-                    Key keyObject = (Key)i.next();
+                    Key keyObject = (Key)derefKey(i.next());
                     result.add(keyObject);
                     i.remove();
                     Object value = super.remove(keyObject);
@@ -282,9 +303,11 @@
         cleanQueue();
         ArrayList result = new ArrayList();
         Set list = getKeys(keyElement);
-        for(Iterator i=list.iterator(); i.hasNext();){
-            Key keyObject = (Key)i.next();
-            result.add(derefValue(super.get(keyObject)));
+        if (list != null) {
+            for(Iterator i=list.iterator(); i.hasNext();){
+                Key keyObject = (Key)derefKey(i.next());
+                result.add(derefValue(super.get(keyObject)));
+            }
         }
         return result;
     }
@@ -305,8 +328,14 @@
             return keys.iterator();
         }
         public boolean equals(Object o){
-            return (o instanceof Key) &&
-            keys.equals(((Key)o).keys);
+            if (o != null && o instanceof Reference) {
+                // on inverse l'egalite pour que la Key soit egal a la ref
+                // si la ref contient la Key
+                return o.equals(this);
+            } else {
+                return (o instanceof Key) &&
+                keys.equals(((Key)o).keys);
+            }
         }
         public int hashCode(){
             int result = 0;
@@ -323,7 +352,7 @@
             String v ="";
             for(int i=0; i<keys.size(); i++){
                 result.append(v);
-                result.append(keys.get(i).toString());
+                result.append(""+keys.get(i));
                 v = ",";
             }
             result.append("]");

Index: lutinutil/src/java/org/codelutin/util/TransparenteWeakReference.java
diff -u lutinutil/src/java/org/codelutin/util/TransparenteWeakReference.java:1.3 lutinutil/src/java/org/codelutin/util/TransparenteWeakReference.java:1.4
--- lutinutil/src/java/org/codelutin/util/TransparenteWeakReference.java:1.3	Thu Oct 27 16:28:00 2005
+++ lutinutil/src/java/org/codelutin/util/TransparenteWeakReference.java	Fri Nov 11 03:16:59 2005
@@ -22,9 +22,9 @@
 *
 * @author Benjamin Poussin <poussin@codelutin.com>
 * Copyright Code Lutin
-* @version $Revision: 1.3 $
+* @version $Revision: 1.4 $
 *
-* Mise a jour: $Date: 2005/10/27 16:28:00 $
+* Mise a jour: $Date: 2005/11/11 03:16:59 $
 * par : $Author: bpoussin $
 */
 package org.codelutin.util;
@@ -85,12 +85,18 @@
         // on travail avec un variable local pour ne pas etre obligé de
         // synchroniser la méthode
         Object local  = get();
+        Object other = o;
         if (o instanceof Reference) {
-            o = ((Reference)o).get();
+            other = ((Reference)o).get();
+
+            if (other == null) {
+                // on fait l'egalite sur les hash car on a perdu les objets
+                return o.hashCode() == hashCode();
+            }
         }
 
-        return (o == null && local == null)
-        || (o != null && o.equals(local));
+        return (other == null && local == null) ||
+            (other != null && other.equals(local));
     }
 
     /**