// synchronized

sclass SeenAndQueue<A> implements Iterable<A> {

  Set<A> seen = syncSet();

  L<A> queue = syncLinkedList();

  Int max; // stop after this many elements if not null

  transient L onAddedToQueue = syncList(); // L<Runnable|voidfunc(A)>

  transient L<Runnable> onQueueEmpty = syncList();

  // queue handler  

  transient ReliableSingleThread rst;

  *() {}

  *(Runnable handler) { rst(handler); }

  bool add(A a) {

    if (a == null || maxReached() || !seen.add(a)) false;

    queue.add(a);

    pcallFAll(onAddedToQueue, a);

    true;

  }

  void addAll(Iterable<A> l) { fOr (A a : l) add(a); }

  A popQueue() {

    ping();

    synchronized(queue) {

      A a = syncPopFirst(queue);

      if (a != null && empty(queue))

        pcallFAll(onQueueEmpty);

      ret a;

    }

  }

  // ends when queue is empty

  ItIt<A> queueIterator() {

    ret iteratorFromFunction_if0(() -> popQueue());

  }

  public ItIt<A> iterator() { ret queueIterator(); }

  void onAddedToQueue(O r) { onAddedToQueue.add(r); }

  ReliableSingleThread rst(Runnable handler) {

    if (rst != null) fail("rst already set");

    rst = ReliableSingleThread(handler);

    onAddedToQueue.add(rst);

    ret rst;

  }

  void cleanMeUp {

    cleanUp(rst);

    rst = null;

  }

  bool queueEmpty() { ret queue.isEmpty(); }

  bool idle() { ret queueEmpty() && !rstRunning(rst); }

  S stats() { ret l(seen) + " seen, " + l(queue) + " queued"

    + (max == null ? "" : ", max: " + max); }

  bool maxReached() { ret max != null && l(seen) + l(queue) >= max; }

  Set<A> asSet() { ret seen; }

}