sclass ExpiringMap2<A, B> extends AbstractMap<A, B> {
  Map<A, Pair<Long, B>> byKey = new HashMap;      // key -> pair(expiry sys time, value)
  new PriorityBlockingQueue<Pair<Long, A>> queue; // queue(pair(expiry sys time, key))
  long standardExpiryTime; // ms
  bool renewOnOverwrite = true, renewOnGet;
  O onChange;
  bool useCountdown = true;
  new RestartableCountdown countdown;

  *() {}
  *(long *standardExpiryTime) {}
  *(long *standardExpiryTime, O *onChange) {}
  *(double standardExpirySeconds) { standardExpiryTime = toMS(standardExpirySeconds); }
  
  synchronized bool clean() {
    bool changes;
    Pair<Long, A> p;
    long time = sysTime();
    while ((p = queue.peek()) != null && time >= p.a) {
      if (useCountdown) countdown.stop();
      
      p = queue.poll();
      ifdef ExpiringMap2_debug
        print("ExpiringMap: retiring key " + p.b);
      endifdef
      Pair<Long, B> v = byKey.get(p.b);
      if (v != null /*&& v.a == p.a*/) {
        ifdef ExpiringMap2_debug
          print("ExpiringMap: retired key " + p.b);
        endifdef
        byKey.remove(p.b);
        set changes;
        change();
      }
    }
    if (useCountdown) 
      countdown.setTargetTime(p != null ? p.a : 0, r clean);
    ret changes;
  }
  
  void change() { callF(onChange); }
  
  synchronized public B put(A a, B b) {
    clean();
    long timeout = sysTime()+standardExpiryTime;
    Pair<Long, B> p = byKey.get(a);
    if (p != null && renewOnOverwrite)
      queue.remove(Pair(p.a, a));
    byKey.put(a, pair(timeout, b));
    change();
    if (p == null || renewOnOverwrite)
      queue.add(Pair(timeout, a));
    ret pairB(p);
  }
  
  synchronized public B remove(O a) {
    clean();
    Pair<Long, B> p = byKey.get(a);
    if (p == null) null;
    queue.remove(Pair(p.a, a));
    byKey.remove(a);
    change();
    ret p.b;
  }
  
  synchronized public B get(O a) {
    clean();
    Pair<Long, B> p = byKey.get(a);
    if (renewOnGet && p != null) {
      queue.remove(Pair(p.a, a));
      long timeout = sysTime()+standardExpiryTime;
      byKey.put((A) a, pair(timeout, p.b));
      queue.add(Pair(timeout, a));
    }
    ret pairB(p);
  }
  
  synchronized public Set<Map.Entry<A,B>> entrySet() {
    clean();
    // TODO: mutex
    ret synchronizedSet(mapValues pairB(byKey).entrySet());
  }
  
  synchronized public Set<A> keySet() {
    clean();
    ret synchronizedSet(byKey.keySet());
  }
  
  synchronized public int size() {
    clean();
    ret byKey.size();
  }
  
  void setStandardExpiryTime(long ms) { standardExpiryTime = ms; }
  
  synchronized ExpiringMap2<A, B> setMap(Map innerMap) {
    byKey = innerMap;
    this;
  }
}