sclass SynchronizedCircularFifoBuffer<E> is Iterable<E>, IntSize {

  int capacity;

  long base;

  ArrayDeque<E> coreStorage; // Unsynched core list

  Cl<E> storage; // synched coreStorage

  *(int capacity) {

    this.capacity = capacity;

    coreStorage = new ArrayDeque<E>(capacity);

    storage = synchronizedCollection(coreStorage);

  }

  /**

   * Adds the given element to the buffer. If the buffer is full, the least recently added element is discarded so

   * that a new element can be inserted.

   */

  public void add(E e) {

    synchronized(storage) {

      if (isFull()) remove();

      coreStorage.addLast(e);

    }

  }

  /**

   * Removes and returns the least recently inserted element from this buffer.

   */

  public E remove() {

    synchronized(storage) {

      ++base;

      return coreStorage.removeFirst();

    }

  }

  /**

   * Returns true iff the buffers remaining capacity is 0.

   */

  public boolean isFull() {

    return storage.size() == capacity;

  }

  /**

   * Returns true iff the buffers size is 0.

   */

  public boolean isEmpty() {

    return storage.isEmpty();

  }

  /**

   * Returns the number of elements in the buffer.

   */

  public int size() {

    return storage.size();

  }

  public Object[] toArray() {

    return storage.toArray();

  }

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

    return storage.toArray(a);

  }

  public List<E> asList() {

    return new ArrayList<E>(storage);

  }

  public Cl<E> getBackingStore() {

    ret storage;

  }

  public Iterator<E> iterator() {

    return storage.iterator();

  }

  public E last() {

    synchronized(storage) {

      ret coreStorage.peekLast();

    }

  }

  public void clear {

    synchronized(storage) {

      coreStorage.clear();

      base = 0;

    }

  }

  // how many elements were discarded

  synchronized long getBase() { ret base; }

  synchronized int getCapacity() { ret capacity; }

}