com.firefly.utils.collection.ArrayQueue Maven / Gradle / Ivy
package com.firefly.utils.collection;
import java.util.AbstractList;
import java.util.NoSuchElementException;
import java.util.Queue;
/* ------------------------------------------------------------ */
/**
* Queue backed by circular array.
*
* This partial Queue implementation (also with {@link #remove()} for stack
* operation) is backed by a growable circular array.
*
*
* @param
* the type of object the queue holds
*/
public class ArrayQueue extends AbstractList implements Queue {
public static final int DEFAULT_CAPACITY = 64;
public static final int DEFAULT_GROWTH = 32;
protected final Object _lock;
protected final int _growCapacity;
protected Object[] _elements;
protected int _nextE;
protected int _nextSlot;
protected int _size;
public ArrayQueue() {
this(DEFAULT_CAPACITY, -1);
}
public ArrayQueue(Object lock) {
this(DEFAULT_CAPACITY, -1, lock);
}
public ArrayQueue(int capacity) {
this(capacity, -1);
}
public ArrayQueue(int initCapacity, int growBy) {
this(initCapacity, growBy, null);
}
public ArrayQueue(int initCapacity, int growBy, Object lock) {
_lock = lock == null ? this : lock;
_growCapacity = growBy;
_elements = new Object[initCapacity];
}
public Object lock() {
return _lock;
}
public int getCapacity() {
synchronized (_lock) {
return _elements.length;
}
}
/**
* @return the next slot to be used
*/
public int getNextSlotUnsafe() {
return _nextSlot;
}
@Override
public boolean add(E e) {
if (!offer(e))
throw new IllegalStateException("Full");
return true;
}
public boolean offer(E e) {
synchronized (_lock) {
return enqueue(e);
}
}
protected boolean enqueue(E e) {
if (_size == _elements.length && !growUnsafe())
return false;
_size++;
_elements[_nextSlot++] = e;
if (_nextSlot == _elements.length)
_nextSlot = 0;
return true;
}
/**
* Add without synchronization or bounds checking
*
* @param e
* the element to add
* @see #add(Object)
*/
public void addUnsafe(E e) {
if (!enqueue(e))
throw new IllegalStateException("Full");
}
public E element() {
synchronized (_lock) {
if (isEmpty())
throw new NoSuchElementException();
return at(_nextE);
}
}
@SuppressWarnings("unchecked")
private E at(int index) {
return (E) _elements[index];
}
public E peek() {
synchronized (_lock) {
if (_size == 0)
return null;
return at(_nextE);
}
}
public E peekUnsafe() {
if (_size == 0)
return null;
return at(_nextE);
}
public E poll() {
synchronized (_lock) {
if (_size == 0)
return null;
return dequeue();
}
}
public E pollUnsafe() {
if (_size == 0)
return null;
return dequeue();
}
protected E dequeue() {
E e = at(_nextE);
_elements[_nextE] = null;
_size--;
if (++_nextE == _elements.length)
_nextE = 0;
return e;
}
public E remove() {
synchronized (_lock) {
if (_size == 0)
throw new NoSuchElementException();
return dequeue();
}
}
@Override
public void clear() {
synchronized (_lock) {
_size = 0;
_nextE = 0;
_nextSlot = 0;
}
}
@Override
public boolean isEmpty() {
synchronized (_lock) {
return _size == 0;
}
}
@Override
public int size() {
synchronized (_lock) {
return _size;
}
}
public int sizeUnsafe() {
return _size;
}
@Override
public E get(int index) {
synchronized (_lock) {
if (index < 0 || index >= _size)
throw new IndexOutOfBoundsException("!(" + 0 + "<" + index
+ "<=" + _size + ")");
return getUnsafe(index);
}
}
/**
* Get without synchronization or bounds checking.
*
* @param index
* index of the element to return
* @return the element at the specified index
* @see #get(int)
*/
public E getUnsafe(int index) {
int i = (_nextE + index) % _elements.length;
return at(i);
}
@Override
public E remove(int index) {
synchronized (_lock) {
if (index < 0 || index >= _size)
throw new IndexOutOfBoundsException("!(" + 0 + "<" + index
+ "<=" + _size + ")");
int i = (_nextE + index) % _elements.length;
E old = at(i);
if (i < _nextSlot) {
// 0 _elements.length
// _nextE........._nextSlot
System.arraycopy(_elements, i + 1, _elements, i, _nextSlot - i);
_nextSlot--;
_size--;
} else {
// 0 _elements.length
// ......_nextSlot _nextE..........
System.arraycopy(_elements, i + 1, _elements, i,
_elements.length - i - 1);
if (_nextSlot > 0) {
_elements[_elements.length - 1] = _elements[0];
System.arraycopy(_elements, 1, _elements, 0, _nextSlot - 1);
_nextSlot--;
} else
_nextSlot = _elements.length - 1;
_size--;
}
return old;
}
}
@Override
public E set(int index, E element) {
synchronized (_lock) {
if (index < 0 || index >= _size)
throw new IndexOutOfBoundsException("!(" + 0 + "<" + index
+ "<=" + _size + ")");
int i = _nextE + index;
if (i >= _elements.length)
i -= _elements.length;
E old = at(i);
_elements[i] = element;
return old;
}
}
@Override
public void add(int index, E element) {
synchronized (_lock) {
if (index < 0 || index > _size)
throw new IndexOutOfBoundsException("!(" + 0 + "<" + index
+ "<=" + _size + ")");
if (_size == _elements.length && !growUnsafe())
throw new IllegalStateException("Full");
if (index == _size) {
add(element);
} else {
int i = _nextE + index;
if (i >= _elements.length)
i -= _elements.length;
_size++;
_nextSlot++;
if (_nextSlot == _elements.length)
_nextSlot = 0;
if (i < _nextSlot) {
// 0 _elements.length
// _nextE.....i..._nextSlot
// 0 _elements.length
// ..i..._nextSlot _nextE..........
System.arraycopy(_elements, i, _elements, i + 1, _nextSlot
- i);
_elements[i] = element;
} else {
// 0 _elements.length
// ......_nextSlot _nextE.....i....
if (_nextSlot > 0) {
System.arraycopy(_elements, 0, _elements, 1, _nextSlot);
_elements[0] = _elements[_elements.length - 1];
}
System.arraycopy(_elements, i, _elements, i + 1,
_elements.length - i - 1);
_elements[i] = element;
}
}
}
}
protected void resizeUnsafe(int newCapacity) {
newCapacity = Math.max(newCapacity, _size);
Object[] elements = new Object[newCapacity];
if (_size > 0) {
if (_nextSlot > _nextE)
System.arraycopy(_elements, _nextE, elements, 0, _size);
else {
int split = _elements.length - _nextE;
System.arraycopy(_elements, _nextE, elements, 0, split);
System.arraycopy(_elements, 0, elements, split, _nextSlot);
}
}
_elements = elements;
_nextE = 0;
_nextSlot = _size;
}
protected boolean growUnsafe() {
if (_growCapacity <= 0)
return false;
resizeUnsafe(_elements.length + _growCapacity);
return true;
}
}