sclass SynchronizedCollection<A> implements Collection<A> {

  Collection<A> c;  // Backing Collection

  Object mutex;     // Object on which to synchronize

  *() {} // for persistence

  *(Collection<A> c) {

      this.c = Objects.requireNonNull(c);

      mutex = this;

  }

  *(Collection<A> c, Object mutex) {

      this.c = Objects.requireNonNull(c);

      this.mutex = Objects.requireNonNull(mutex);

  }

  public int size() {

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

  }

  public boolean isEmpty() {

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

  }

  public boolean contains(Object o) {

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

  }

  public Object[] toArray() {

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

  }

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

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

  }

  public Iterator<A> iterator() {

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

  }

  public boolean add(A A) {

      synchronized (mutex) {return c.add(A);}

  }

  public boolean remove(Object o) {

      synchronized (mutex) {return c.remove(o);}

  }

  public boolean containsAll(Collection<?> coll) {

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

  }

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

      synchronized (mutex) {return c.addAll(coll);}

  }

  public boolean removeAll(Collection<?> coll) {

      synchronized (mutex) {return c.removeAll(coll);}

  }

  public boolean retainAll(Collection<?> coll) {

      synchronized (mutex) {return c.retainAll(coll);}

  }

  public void clear() {

      synchronized (mutex) {c.clear();}

  }

  public String toString() {

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

  }

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

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

  }*/

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

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

  }*/

  @Override

  public Spliterator<A> spliterator() {

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

  }

  /*public Stream<A> stream() {

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

  }*/

  /*public Stream<A> parallelStream() {

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

  }*/

}