sclass WeakValueMap<A, B> is AutoCloseable, IntSize {

  // A value that has been stored with this key has been garbage

  // collected.

  event valueForKeyReleased(A key);

  // internal

  Map<A, WeakRef<B>> map = syncMap();

  RunnablesReferenceQueue queue;

  bool myQueue = true;

  *() {}

  *(RunnablesReferenceQueue *queue) { myQueue = false; }

  class MyRef extends WeakRef<B> is Runnable {

    A key;

    *(A *key, B value) { super(value, queue()!); }

    run {

      bool current = syncMapRemoveKeyAndValuePair(map, key, this);

      // Note that the value may be stale (replaed by another value in

      // the meantime). If you want to distinguish that kind of event

      // from a non-stale value being released, check the variable

      // "current".

      valueForKeyReleased(key);

    }

  }

  // public methods follow

  B get(A key) {

    ret getWeakRef(map.get(key));

  }

  B put(A key, B value) {

    synchronized(mutex()) {

      if (value == null) {

        B old = getWeakRef(map.get(key));

        map.remove(key);

        ret old;

      } else

        ret getWeakRef(map.put(key, new MyRef(key, value)));

    }

  }

  O mutex() { ret collectionMutex(map); }

  RunnablesReferenceQueue queue() {

    synchronized(mutex()) {

      if (queue == null) queue = new RunnablesReferenceQueue;

      ret queue;

    }

  }

  close {

    if (myQueue)

      synchronized(mutex()) {  

        dispose queue;

      }

  }

  public int size() { ret map.size(); }

  Map<A, B> snapshot() {

    synchronized(mutex()) {

      new Map<A, B> snapshot;

      for (key, ref : map)

        mapPut(snapshot, key, getWeakRef(ref));

      ret snapshot;

    }

  }

  void setQueue aka queue(RunnablesReferenceQueue queue) {

    synchronized(mutex()) {  

      if (queue == null || this.queue == queue) ret;

      if (this.queue != null)

        fail("Can't change queue once we're started");

      this.queue = queue;

      myQueue = false;

    }

  }

}