RingBuffer.java

package au.gov.amsa.util;

import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;

import net.jcip.annotations.NotThreadSafe;

/**
 * Non-threadsafe implementation of a Ring Buffer. Does not accept nulls.
 * 
 * @param <T>
 */
@NotThreadSafe
public class RingBuffer<T> implements Queue<T> {

    private final T[] list;
    private int start;
    private int finish;

    @SuppressWarnings("unchecked")
    private RingBuffer(int size) {
        list = (T[]) new Object[size + 1];
    }

    public static <T> RingBuffer<T> create(int size) {
        return new RingBuffer<T>(size);
    }

    @Override
    public void clear() {
        finish = start;
    }

    @Override
    public Iterator<T> iterator() {
        final int _start = start;
        final int _finish = finish;
        return new Iterator<T>() {
            int i = _start;

            @Override
            public boolean hasNext() {
                return i != _finish;
            }

            @Override
            public T next() {
                T value = list[i];
                i = (i + 1) % list.length;
                return value;
            }
        };
    }

    @Override
    public T peek() {
        if (start == finish)
            return null;
        else
            return list[start];
    }

    public boolean isEmpty() {
        return start == finish;
    }

    public int size() {
        if (start <= finish)
            return finish - start;
        else
            return finish - start + list.length;
    }

    public int maxSize() {
        return list.length - 1;
    }

    @Override
    public boolean contains(Object o) {
        return notImplemented();
    }

    @Override
    public Object[] toArray() {
        return notImplemented();
    }

    @Override
    public <S> S[] toArray(S[] a) {
        return notImplemented();
    }

    @Override
    public boolean remove(Object o) {
        return notImplemented();
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return notImplemented();
    }

    private static <T> T notImplemented() {
        throw new RuntimeException("Not implemented");
    }

    @Override
    public boolean addAll(Collection<? extends T> c) {
        for (T t : c)
            add(t);
        return true;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return notImplemented();
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return notImplemented();
    }

    @Override
    public boolean add(T t) {
        if (offer(t))
            return true;
        else
            throw new IllegalStateException("Cannot add to queue because is full");
    }

    @Override
    public boolean offer(T t) {
        if (t == null)
            throw new NullPointerException();
        int currentFinish = finish;
        finish = (finish + 1) % list.length;
        if (finish == start) {
            return false;
        } else {
            list[currentFinish] = t;
            return true;
        }
    }

    @Override
    public T remove() {
        T t = poll();
        if (t == null)
            throw new NoSuchElementException();
        else
            return t;
    }

    @Override
    public T poll() {
        if (start == finish) {
            return null;
        } else {
            T value = list[start];
            // don't hold a reference to a popped value
            list[start] = null;
            start = (start + 1) % list.length;
            return value;
        }
    }

    @Override
    public T element() {
        return notImplemented();
    }
}