aqueue.java

用java开发的一个实施策略游戏源码 值得学习一下

/*
	Netwar
	Copyright (C) 2002  Daniel Grund, Kyle Kakligian, Jason Komutrattananon, & Brian Hibler.

	This file is part of Netwar.

	Netwar is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	Netwar is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with Netwar; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package netwar.utils;

/** Array based Queue class
 * @author Kyle Kakligian
 */
public class AQueue implements Queue {
	private static final int defaultSize = 10;
	private int maxSize;               // Maximum size of queue
	private int front;              // Index prior to front item
	private int rear;               // Index of rear item+1
	private Object [] listArray;    // Array holding Objects
/** Constructs a AQueue
 */
	public AQueue() { setup(defaultSize); } // Constructor: default size
        /** Constructs a AQueue
         * @param size Default Queue size.
         */
        public AQueue(int size) { setup(size); }    // Constructor: set size

	private void setup(int sz)              // Initialize queue
	{ maxSize = sz;  front = rear = 0;  listArray = new Object[sz]; }
        /** Internally resizes the queue to hold at least the given number of items
         * @param newSize Resize the Quesue to hold atleast <B>newSize</B> Objects.
         */
	public void resize(int newSize) { // Make vector at least as large as newSize
		if(maxSize >= newSize)
		return;
		Object newArray[] = new Object[newSize];
		for(int t = 0; t < getNumInList(); t++) newArray[t] = listArray[(front + t)%maxSize];
		listArray = newArray;
		front = 0;
		rear = getNumInList();
		maxSize = newSize;
	}
        /** Internally resizes the queue to hold at least the given number of items */
	public void shrink() {
		Object newArray[] = new Object[getNumInList()];
		for(int t = 0; t < getNumInList(); t++) newArray[t] = listArray[(front + t)%maxSize];
		listArray = newArray;
		maxSize = getNumInList();
		front = 0;
		rear = maxSize;
	}
/** Clears the queue.
 */
	public void clear()             // Remove all Objects from queue
	{ front = rear = 0; }
	private int getNumInList() {
		int ret = rear - front;
		if(ret <0) ret += maxSize;
		return ret;
	}
/** if overflow, auto-resize to x2
 */
	private void larger() {resize(maxSize*2);}
        /** Enqueues an Object.
         * @param it The Object to enqueue.
         */
	public void enqueue(Object it) { // Enqueue Object at rear
		if(getNumInList() == maxSize)
		larger();

		rear = (rear+1) % maxSize;       // Increment rear (in circle)
		listArray[rear] = it;
	}
        /** Dequeues an Object.
         * @return The dequeued Object.
         */
	public Object dequeue() {       // Dequeue Object from front
		if(front == rear)
		return null;
		front = (front+1) % maxSize;     // Increment front
		return listArray[front];      // Return value
	}
        /** Peeks at the next Object to dequeue.
         * @return The next Object to dequeue.
         */
	public Object peek() {    // Return value of front Object
		if(front == rear)
		return null;
		return listArray[(front+1) % maxSize];
	}
        /** Returns whether or not the queue is empty.
         * @return true if empty.
         */
	public boolean isEmpty()        // Return true if queue is empty
	{ return front == rear; }
} // class AQueue