import org.andengine.util.adt.list.IList; //导入依赖的package包/类
public T peek() {
	final ReentrantLock lock = this.mLock;
	lock.lock();

	try {
		if (this.mSize == 0) {
			return null;
		} else {
			final SparseArray<IList<T>> queues = this.mQueues; 
			final int queueCount = queues.size();
			for (int i = 0; i < queueCount; i++) {
				final IList<T> queue = this.mQueues.valueAt(i);
				if (queue.size() > 0) {
					return queue.get(0);
				}
			}
			return null;
		}
	} finally {
		lock.unlock();
	}
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
/**
 * Inserts the specified element at the tail of this queue with the given priority, if it is possible without exceeding the capacity of the queue with the given priority.
 * 
 * @throws IllegalArgumentException if pItem is <code>null</code>
 * @return <code>true</code> if the 
 */
public boolean offer(final int pPriority, final T pItem) throws IllegalArgumentException {
	if (pItem == null) { 
		throw new IllegalArgumentException("pItem must not be null.");
	}

	final ReentrantLock lock = this.mLock;
	lock.lock();

	try {
		final IList<T> queue = this.mQueues.get(pPriority);
		if (queue == null) {
			throw new IllegalArgumentException("No queue found for pPriority: '" + pPriority + "'.");
		}

		final int queueCapacity = this.mQueueCapacities.get(pPriority);
		if (queue.size() == queueCapacity) {
			return false;
		} else {
			insert(pPriority, pItem);
			return true;
		}
	} finally {
		lock.unlock();
	}
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
public void clear() {
	final ReentrantLock lock = this.mLock;
	lock.lock();

	try {
		if (this.mSize > 0) {
			final SparseArray<IList<T>> queues = this.mQueues; 
			final int queueCount = queues.size();
			for (int i = 0; i < queueCount; i++) {
				final int priority = this.mQueues.keyAt(i);

				final IList<T> queue = this.mQueues.valueAt(i);
				queue.clear();

				final Condition notFullCondition = this.mNotFullConditions.get(priority);
				notFullCondition.signal();
			}
			this.mSize = 0;
		}
	} finally {
		lock.unlock();
	}
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
@Override
public String toString() {
	final ReentrantLock lock = this.mLock;
	lock.lock();

	try {
		final StringBuilder stringBuilder = new StringBuilder();

		if (this.mQueues.size() > 0) {
			final SparseArray<IList<T>> queues = this.mQueues;
			final SparseIntArray queueCapacities = this.mQueueCapacities;

			stringBuilder.append(" [\n");

			final int queueCount = queues.size();
			for (int i = 0; i < queueCount; i++) {
				final int priority = queues.keyAt(i);
				final IList<T> queue = queues.valueAt(i);
				final int queueCapacity = queueCapacities.valueAt(i);
				final int queueSize = queue.size();

				stringBuilder.append("\tPriority: ").append(priority).append(" (Capacity: ").append(queueSize).append('/').append(queueCapacity).append("): ");
				stringBuilder.append(queue.toString());

				if (i < (queueCount - 1)) {
					stringBuilder.append(',');
				}
				stringBuilder.append('\n');
			}

			stringBuilder.append(']');
		}

		return stringBuilder.toString();
	} finally {
		lock.unlock();
	}
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
private void insert(final int pPrority, final T pItem) { // TODO Causes another (potentially unnecessary) lookup for the queue
	final IList<T> queue = this.mQueues.get(pPrority);
	queue.add(pItem);
	this.mSize++;

	this.mNotEmptyCondition.signal();
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
private T extract() {
	final SparseArray<IList<T>> queues = this.mQueues; 
	final int queueCount = queues.size();
	for (int i = 0; i < queueCount; i++) {
		final IList<T> queue = this.mQueues.valueAt(i);
		if (queue.size() > 0) {
			final int priority = this.mQueues.keyAt(i);
			return this.extract(priority);
		}
	}
	return null;
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
/**
 * Inserts the specified element at the tail of this queue with the given priority, waiting for space to become available if the queue is full.
 * 
 * @throws IllegalArgumentException if pItem is <code>null</code>
 * @throws InterruptedException 
 */
public void put(final int pPriority, final T pItem) throws IllegalArgumentException, InterruptedException {
	if (pItem == null) { 
		throw new IllegalArgumentException("pItem must not be null.");
	}

	final ReentrantLock lock = this.mLock;
	final Condition notFullCondition = this.mNotFullConditions.get(pPriority);
	lock.lockInterruptibly();

	try {
		final IList<T> queue = this.mQueues.get(pPriority);
		if (queue == null) {
			throw new IllegalArgumentException("No queue found for pPriority: '" + pPriority + "'.");
		}

		final int queueCapacity = this.mQueueCapacities.get(pPriority);
		try {
			while (queue.size() == queueCapacity) {
				notFullCondition.await();
			}
		} catch (final InterruptedException e) {
			/* Propagate to non-interrupted thread. */
			notFullCondition.signal();
			throw e;
		}
		insert(pPriority, pItem);
	} finally {
		lock.unlock();
	}
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
@Override
public void sort(final IList<T> pList, final int pStart, final int pEnd, final Comparator<T> pComparator) {
	for (int i = pStart + 1; i < pEnd; i++) {
		final T current = pList.get(i);
		T prev = pList.get(i - 1);
		if (pComparator.compare(current, prev) < 0) {
			int j = i;
			do {
				pList.set(j--, prev);
			} while (j > pStart && pComparator.compare(current, prev = pList.get(j - 1)) < 0);
			pList.set(j, current);
		}
	}
	return;
}
 

import org.andengine.util.adt.list.IList; //导入依赖的package包/类
@Override
public void sort(final IList<T> pList, final int pStart, final int pEnd, final Comparator<T> pComparator) {
	for(int i = pStart + 1; i < pEnd; i++) {
		final T current = pList.get(i);
		T prev = pList.get(i - 1);
		if(pComparator.compare(current, prev) < 0) {
			int j = i;
			do {
				pList.set(j--, prev);
			} while(j > pStart && pComparator.compare(current, prev = pList.get(j - 1)) < 0);
			pList.set(j, current);
		}
	}
	return;
}