ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/experimental/server/Queue/Queue.java

Comparing experimental/server/Queue/Queue.java (file contents):
Revision 1.3 by tdb, Tue Jan 2 01:50:17 2001 UTC vs.
Revision 1.7 by tdb, Mon Feb 12 02:27:56 2001 UTC

#	Line 1 | Line 1
1		//---PACKAGE DECLARATION---
2	+	//package uk.ac.ukc.iscream.util;
3
4		//---IMPORTS---
5		import java.util.LinkedList;
#	Line 14 | Line 15 | import java.util.NoSuchElementException;
15		* @author  $Author$
16		* @version $Id$
17		*/
18	<	class Queue {
18	>	public class Queue {
19
20		//---FINAL ATTRIBUTES---
21
#	Line 61 | Line 62 | class Queue {
62		* This method returns an object from the front of a given queue.
63		* It will block until data exists in the queue if required.
64		*
65	+	* @param The queue to retrieve data from.
66		* @return The object from the front of the queue.
67		* @throws InvalidQueueException if the queue does not exist.
68		*/
#	Line 87 | Line 89 | class Queue {
89		}
90		return o;
91		}
92	<
92	>
93		/**
94	<	* This method returns a textual status of the queues. It
95	<	* is merely for observation, and would most likely be used
96	<	* by a larger "monitoring" component. Information returned
97	<	* includes the current size of each queue, and the total
96	<	* items passed through.
94	>	* This method releases a get() method that's currently
95	>	* waiting on an empty queue. This was designed for
96	>	* shutdown() type methods that may have problems closing
97	>	* if the thread of control is waiting on a queue.
98		*
99	<	* @return A String message containing status information.
99	>	* @param queue the queue to release.
100		*/
101	<	public String status() {
102	<	String status = "";
101	>	public void releaseQueue(int queue) {
102	>	synchronized(((LinkedList) _lists.get(queue))) {
103	>	((LinkedList) _lists.get(queue)).notifyAll();
104	>	}
105	>	}
106	>
107	>	/**
108	>	* This method erases the contents of a given queue. This
109	>	* method should be used with care. It can only empty one
110	>	* internal queue, not all of them. This must be called
111	>	* multiple times to empty all queues.
112	>	*
113	>	* @param queue the queue to empty.
114	>	*/
115	>	public void clearQueue(int queue) {
116	>	synchronized(this) {
117	>	((LinkedList) _lists.get(queue)).clear();
118	>	}
119	>	}
120	>
121	>	/**
122	>	* This method returns an XML textual status of the queues.
123	>	* It is merely for observation, and would most likely be
124	>	* used by a larger "monitoring" component. Information
125	>	* returned includes the current size of each queue, and
126	>	* the total items passed through.
127	>	*
128	>	* @return A String message containing status information in XML format
129	>	*/
130	>	public String xmlStatus() {
131	>	String status = "<queue ";
132		for(int i=0; i < _lists.size(); i++) {
133		// check for null entries
134		if(_lists.get(i) != null) {
135	<	status += "Queue number "+i+" contains "+((LinkedList) _lists.get(i)).size()+" elements";
106	<	status += "\n";
135	>	status += "queue"+i+"=\""+((LinkedList) _lists.get(i)).size()+"\" ";
136		}
137		else {
138	<	status += "Slot number "+i+" is currently empty";
110	<	status += "\n";
138	>	status += "queue"+i+"=\"null\" ";
139		}
140		}
141	<	status += "A total of "+_count+" elements have been added to the queues";
141	>	status += "total=\""+_count+"\"></queue>";
142		return status;
143		}
144
145		/**
146	+	* Returns the size of a given queue. A consumer can use
147	+	* this to see how big their queue is at any given time.
148	+	* they should use their queue number as the parameter.
149	+	*
150	+	* @param queue The queue number to query.
151	+	* @return the current size of the queue.
152	+	* @throws InvalidQueueException if the queue does not exist.
153	+	*/
154	+	public int queueSize(int queue) throws InvalidQueueException {
155	+	if (queue >= _lists.size() || _lists.get(queue) == null) {
156	+	throw new InvalidQueueException("Requested queue "+queue+" does not exist");
157	+	}
158	+	return ((LinkedList) _lists.get(queue)).size();
159	+	}
160	+
161	+	/**
162	+	* Returns the total numer of elements to have passed
163	+	* through this queue (ie. a counter on the add method).
164	+	*
165	+	* @return the element-ometer.
166	+	*/
167	+	public int elementCount() {
168	+	return _count;
169	+	}
170	+
171	+	/**
172		* This method assigns a queue to a consumer. The idea behind
173		* this is to ensure that only 1 consumer can be associated with
174		* a given queue, otherwise the whole "blocking" thing fails
#	Line 154 | Line 208 | class Queue {
208		}
209
210		/**
211	+	* Start a monitor on our own Queue. This will log XML
212	+	* statistics about our Queue to a given Queue (could be
213	+	* the one being monitored).
214	+	*
215	+	* @param interval The long interval, in milliseconds, at which to take samples
216	+	* @param destQueue The queue to monitor to
217	+	* @param name A name to identify this Queue with
218	+	* @return whether we succeeded
219	+	*/
220	+	public boolean startMonitor(long interval, Queue destQueue, String name) {
221	+	if(_queueMon == null) {
222	+	// start a monitor
223	+	_queueMon = new QueueMonitor(this, destQueue, interval, name);
224	+	_queueMon.start();
225	+	return true;
226	+	}
227	+	else {
228	+	// already have a monitor running
229	+	return false;
230	+	}
231	+	}
232	+
233	+	/**
234	+	* Start a monitor on our own Queue. This will log XML
235	+	* statistics about our Queue to this Queue.
236	+	*
237	+	* @param interval The long interval, in milliseconds, at which to take samples
238	+	* @param name A name to identify this Queue with
239	+	* @return whether we succeeded
240	+	*/
241	+	public boolean startMonitor(long interval, String name) {
242	+	return startMonitor(interval, this, name);
243	+	}
244	+
245	+	/**
246	+	* Stop a monitor on our Queue if we have on running.
247	+	*
248	+	* @return whether we succeeded
249	+	*/
250	+	public boolean stopMonitor() {
251	+	if(_queueMon != null) {
252	+	// stop a monitor
253	+	_queueMon.shutdown();
254	+	_queueMon = null;
255	+	return true;
256	+	}
257	+	else {
258	+	// no monitor running
259	+	return false;
260	+	}
261	+	}
262	+
263	+	/**
264		* Overrides the {@link java.lang.Object#toString() Object.toString()}
265		* method to provide clean logging (every class should have this).
266		*
267		* This uses the uk.ac.ukc.iscream.util.FormatName class
268		* to format the toString()
269		*
270	<	* @return the name of this class and its CVS revision
270	>	* @return the name of this class and its CVS revision.
271		*/
272	<	/*public String toString() {
272	>	public String toString() {
273		return FormatName.getName(
274		_name,
275		getClass().getName(),
276		REVISION);
277	<	}*/
277	>	}
278
279		//---PRIVATE METHODS---
280
#	Line 187 | Line 294 | class Queue {
294		private int _count = 0;
295
296		/**
297	+	* A reference to our QueueMonitor, if we have one.
298	+	*/
299	+	private QueueMonitor _queueMon = null;
300	+
301	+	/**
302		* This is the friendly identifier of the
303		* component this class is running in.
304		* eg, a Filter may be called "filter1",
#	Line 195 | Line 307 | class Queue {
307		* can be placed here.  This name could also
308		* be changed to null for utility classes.
309		*/
310	<	//private String _name = <!THIS SHOULD CALL A STATIC NAME IN THE COMPONENT CLASS FOR THIS OBJECT!>;
199	<
200	<	/**
201	<	* This holds a reference to the
202	<	* system logger that is being used.
203	<	*/
204	<	//private Logger _logger = ReferenceManager.getInstance().getLogger();
310	>	private String _name = null;
311
312		//---STATIC ATTRIBUTES---
313

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines