public UnboundedFifoBuffer() 
{
        this(32);
}

Constructs an UnboundedFifoBuffer with the default number of elements. It is exactly the same as performing the following:

new UnboundedFifoBuffer(32);

 public UnboundedFifoBuffer(int initialSize) 
{
        if (initialSize < = 0) {
            throw new IllegalArgumentException("The size must be greater than 0");
        }
        m_buffer = new Object[initialSize + 1];
        m_head = 0;
        m_tail = 0;
}

Constructs an UnboundedFifoBuffer with the specified number of elements. The integer must be a positive integer.

Parameters:

initialSize - the initial size of the buffer

Throws:

IllegalArgumentException - if the size is less than 1

 public boolean add(Object obj) 
{
        if (obj == null) {
            throw new NullPointerException("Attempted to add null object to buffer");
        }
        if (size() + 1  >= m_buffer.length) {
            Object[] tmp = new Object[((m_buffer.length - 1) * 2) + 1];
            int j = 0;
            for (int i = m_head; i != m_tail;) {
                tmp[j] = m_buffer[i];
                m_buffer[i] = null;
                j++;
                i++;
                if (i == m_buffer.length) {
                    i = 0;
                }
            }
            m_buffer = tmp;
            m_head = 0;
            m_tail = j;
        }
        m_buffer[m_tail] = obj;
        m_tail++;
        if (m_tail  >= m_buffer.length) {
            m_tail = 0;
        }
        return true;
}

Adds the given element to this buffer.

 public Object get() 
{
        if (isEmpty()) {
            throw new BufferUnderflowException("The buffer is already empty");
        }
        return m_buffer[m_head];
}

Returns the next object in the buffer.

 public boolean isEmpty() 
{
        return (size() == 0);
}

Returns true if this buffer is empty; false otherwise.

 public Iterator iterator() 
{
        return new Iterator() {
            private int index = m_head;
            private int lastReturnedIndex = -1;
            public boolean hasNext() {
                return index != m_tail;
            }
            public Object next() {
                if (!hasNext())
                    throw new NoSuchElementException();
                lastReturnedIndex = index;
                index = increment(index);
                return m_buffer[lastReturnedIndex];
            }
            public void remove() {
                if (lastReturnedIndex == -1)
                    throw new IllegalStateException();
                // First element can be removed quickly
                if (lastReturnedIndex == m_head) {
                    UnboundedFifoBuffer.this.remove();
                    lastReturnedIndex = -1;
                    return;
                }
                // Other elements require us to shift the subsequent elements
                int i = increment(lastReturnedIndex);
                while (i != m_tail) {
                    m_buffer[decrement(i)] = m_buffer[i];
                    i = increment(i);
                }
                lastReturnedIndex = -1;
                m_tail = decrement(m_tail);
                m_buffer[m_tail] = null;
                index = decrement(index);
            }
        };
}

Returns an iterator over this buffer's elements.

 public Object remove() 
{
        if (isEmpty()) {
            throw new BufferUnderflowException("The buffer is already empty");
        }
        Object element = m_buffer[m_head];
        if (null != element) {
            m_buffer[m_head] = null;
            m_head++;
            if (m_head  >= m_buffer.length) {
                m_head = 0;
            }
        }
        return element;
}

Removes the next object from the buffer

 public int size() 
{
        int size = 0;
        if (m_tail <  m_head) {
            size = m_buffer.length - m_head + m_tail;
        } else {
            size = m_tail - m_head;
        }
        return size;
}

Returns the number of elements stored in the buffer.