persistable sclass NotifyingCollection<E> extends AbstractCollection<E> implements Collection<E> {

  Collection<E> c;  // Backing Collection

  *() {} // for persistence

  *(Collection<E> *c) {}

  public int size() {

      synchronized (this) {return c.size();}

  }

  public boolean isEmpty() {

      synchronized (this) {return c.isEmpty();}

  }

  public boolean contains(Object o) {

      synchronized (this) {return c.contains(o);}

  }

  public Object[] toArray() {

      synchronized (this) {return c.toArray();}

  }

  public <T> T[] toArray(T[] a) {

      synchronized (this) {return c.toArray(a);}

  }

  public Iterator<E> iterator() {

      return c.iterator(); // caller should not use Iterator.remove()

  }

  public boolean add(E e) {

      synchronized (this) { beforeChange(); if (!c.add(e)) false; } change(); true;

  }

  public boolean remove(Object o) {

      synchronized (this) { beforeChange(); if (!c.remove(o)) false;} change(); true;

  }

  public boolean containsAll(Collection<?> coll) {

      synchronized (this) {return c.containsAll(coll);}

  }

  public boolean addAll(Collection<? extends E> coll) {

      synchronized (this) { beforeChange(); if (!c.addAll(coll)) false;} change(); true;

  }

  public boolean removeAll(Collection<?> coll) {

      synchronized (this) { beforeChange(); if (!c.removeAll(coll)) false;} change(); true;

  }

  public boolean retainAll(Collection<?> coll) {

      synchronized (this) { beforeChange(); if (!c.retainAll(coll)) false;} change(); true;

  }

  public void clear() {

      synchronized (this) { beforeChange(); c.clear();} change();

  }

  public String toString() {

      synchronized (this) {return c.toString();}

  }

  /*public void forEach(Consumer<? super E> consumer) {

      synchronized (this) {c.forEach(consumer);}

  }*/

  /*public boolean removeIf(Predicate<? super E> filter) {

      synchronized (this) {return c.removeIf(filter);}

  }*/

  @Override

  public Spliterator<E> spliterator() {

      return c.spliterator(); // Must be manually synched by user!

  }

  /*public Stream<E> stream() {

      return c.stream(); // Must be manually synched by user!

  }*/

  /*public Stream<E> parallelStream() {

      return c.parallelStream(); // Must be manually synched by user!

  }*/

  void beforeChange() {}

  void change() {}

  Collection<E> unwrap() { ret c; }

}