import java.util.NoSuchElementException;

  /**

   * Thread safe fixed size circular buffer implementation. Backed by an array.

   *

   * @author brad

   */

  public class ArrayCircularBuffer<T> {

       // internal data storage

       private T[] data;

       // indices for inserting and removing from queue

       private int front = ;

       private int insertLocation = ;

       // number of elements in queue

       private int size = ;

       /**

        * Creates a circular buffer with the specified size.

        *

        * @param bufferSize

        *      - the maximum size of the buffer

        */

       public ArrayCircularBuffer(int bufferSize) {

            data = (T[]) new Object[bufferSize];

       }

       /**

        * Inserts an item at the end of the queue. If the queue is full, the oldest

        * value will be removed and head of the queue will become the second oldest

        * value.

        *

        * @param item

        *      - the item to be inserted

        */

       public synchronized void insert(T item) {

            data[insertLocation] = item;

            insertLocation = (insertLocation + ) % data.length;

            /**

             * If the queue is full, this means we just overwrote the front of the

             * queue. So increment the front location.

             */

            if (size == data.length) {

                 front = (front + ) % data.length;

            } else {

                 size++;

            }

       }

       /**

        * Returns the number of elements in the buffer

        *

        * @return int - the number of elements inside this buffer

        */

       public synchronized int size() {

            return size;

       }

       /**

        * Returns the head element of the queue.

        *

        * @return T

        */

       public synchronized T removeFront() {

            if (size == ) {

                 throw new NoSuchElementException();

            }

            T retValue = data[front];

            front = (front + ) % data.length;

            size--;

            return retValue;

       }

       /**

        * Returns the head of the queue but does not remove it.

        *

        * @return

        */

       public synchronized T peekFront() {

            if (size == ) {

                 return null;

            } else {

                 return data[front];

            }

       }

       /**

        * Returns the last element of the queue but does not remove it.

        *

        * @return T - the most recently added value

        */

       public synchronized T peekLast() {

            if (size == ) {

                 return null;

            } else {

                 int lastElement = insertLocation - ;

                 if (lastElement < ) {

                      lastElement = data.length - ;

                 }

                 return data[lastElement];

            }

       }

  }