// a persistent map using a clever combination of persisting and logging
// (well, only logging as of now)
// Uses TreeMap as default
// Note: don't put in static initializer (programID not set yet)
static class PersistentMap<A, B> extends AbstractMap<A, B> {
  Map<A, B> m = makeMap();
  File file;
  S id; // unique ID of this map
  
  Map<A, B> makeMap() {
    ret new TreeMap();
  }
  
  PersistentMap(S fileName) {
    this(getProgramFile(fileName));
  }
  
  PersistentMap(S progID, S fileName) {
    this(getProgramFile(progID, fileName));
  }
  
  *(File *file) {
    for (S s : scanLog(file)) pcall {
      L l = cast unstructure(s);
      O cmd = l.get(0);
      if (eq(cmd, "add"))
        m.put((A) l.get(1), (B) l.get(2));
      else if (eq(cmd, "remove"))
        m.remove((A) l.get(1));
      else if (eq(cmd, "id"))
        id = (S) l.get(1);
      else
        print("Unknown command in log: " + l.get(0));
    }
    
    if (id == null)
      makeID_priv();
  }
  
  void makeID_priv() {
    id = makeRandomID(12);
    logQuoted(file, structure(litlist("id", id)));
  }
  
  // just delegates
  
  public synchronized int size() {
    ret m.size();
  }
  
  public synchronized B get(O a) {
    ret m.get(a);
  }
  
  // TODO: calling remove() in the iterator will have unpersisted
  // effects.
  public synchronized Set<Map.Entry<A,B>> entrySet() {
    ret m.entrySet(); // synchronize this?
  }
  
  // delegates with logging

  public synchronized B put(A a, B b) {
    B c = m.get(a);
    if (neq(b, c)) {
      m.put(a, b);
      logQuoted(file, structure(litlist("add", a, b)));
    }
    ret c;
  }
  
  public synchronized B remove(O a) {
    B result = m.remove(a);
    logQuoted(file, structure(litlist("remove", a)));
    ret result;
  }
  
  // unique id of this map
  public S id() {
    ret id;
  }
  
  // clear map, make new ID
  public synchronized void clear() {
    m.clear();
    file.delete();
    makeID_priv();
  }
}