ViewVC Help

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

root/jsr166/jsr166/src/main/java/util/ArrayDeque.java

Comparing jsr166/src/main/java/util/ArrayDeque.java (file contents):
Revision 1.9 by jsr166, Mon May 16 06:16:12 2005 UTC vs.
Revision 1.17 by dl, Thu Sep 15 16:55:24 2005 UTC

#	Line 4 | Line 4
4		*/
5
6		package java.util;
7	+	import java.util.*; // for javadoc (till 6280605 is fixed)
8		import java.io.*;
9
10		/**
#	Line 202 | Line 203 | public class ArrayDeque<E> extends Abstr
203
204		/**
205		* Inserts the specified element at the end of this deque.
206	<	* This method is equivalent to {@link #add} and {@link #push}.
206	>	*
207	>	* <p>This method is equivalent to {@link #add}.
208		*
209		* @param e the element to add
210		* @throws NullPointerException if the specified element is null
#	Line 219 | Line 221 | public class ArrayDeque<E> extends Abstr
221		* Inserts the specified element at the front of this deque.
222		*
223		* @param e the element to add
224	<	* @return <tt>true</tt> (as per the spec for {@link Deque#offerFirst})
224	>	* @return <tt>true</tt> (as specified by {@link Deque#offerFirst})
225		* @throws NullPointerException if the specified element is null
226		*/
227		public boolean offerFirst(E e) {
#	Line 231 | Line 233 | public class ArrayDeque<E> extends Abstr
233		* Inserts the specified element at the end of this deque.
234		*
235		* @param e the element to add
236	<	* @return <tt>true</tt> (as per the spec for {@link Deque#offerLast})
236	>	* @return <tt>true</tt> (as specified by {@link Deque#offerLast})
237		* @throws NullPointerException if the specified element is null
238		*/
239		public boolean offerLast(E e) {
#	Line 313 | Line 315 | public class ArrayDeque<E> extends Abstr
315		* If the deque does not contain the element, it is unchanged.
316		* More formally, removes the first element <tt>e</tt> such that
317		* <tt>o.equals(e)</tt> (if such an element exists).
318	<	* Returns true if this deque contained the specified element (or
319	<	* equivalently, if this deque changed as a result of the call).
318	>	* Returns <tt>true</tt> if this deque contained the specified element
319	>	* (or equivalently, if this deque changed as a result of the call).
320		*
321		* @param o element to be removed from this deque, if present
322		* @return <tt>true</tt> if the deque contained the specified element
#	Line 341 | Line 343 | public class ArrayDeque<E> extends Abstr
343		* If the deque does not contain the element, it is unchanged.
344		* More formally, removes the last element <tt>e</tt> such that
345		* <tt>o.equals(e)</tt> (if such an element exists).
346	<	* Returns true if this deque contained the specified element (or
347	<	* equivalently, if this deque changed as a result of the call).
346	>	* Returns <tt>true</tt> if this deque contained the specified element
347	>	* (or equivalently, if this deque changed as a result of the call).
348		*
349		* @param o element to be removed from this deque, if present
350		* @return <tt>true</tt> if the deque contained the specified element
#	Line 371 | Line 373 | public class ArrayDeque<E> extends Abstr
373		* <p>This method is equivalent to {@link #addLast}.
374		*
375		* @param e the element to add
376	<	* @return <tt>true</tt> (as per the spec for {@link Collection#add})
376	>	* @return <tt>true</tt> (as specified by {@link Collection#add})
377		* @throws NullPointerException if the specified element is null
378		*/
379		public boolean add(E e) {
#	Line 385 | Line 387 | public class ArrayDeque<E> extends Abstr
387		* <p>This method is equivalent to {@link #offerLast}.
388		*
389		* @param e the element to add
390	<	* @return <tt>true</tt> (as per the spec for {@link Queue#offer})
390	>	* @return <tt>true</tt> (as specified by {@link Queue#offer})
391		* @throws NullPointerException if the specified element is null
392		*/
393		public boolean offer(E e) {
#	Line 394 | Line 396 | public class ArrayDeque<E> extends Abstr
396
397		/**
398		* Retrieves and removes the head of the queue represented by this deque.
399	<	* This method differs from {@link #poll} only in that it throws an
399	>	*
400	>	* This method differs from {@link #poll poll} only in that it throws an
401		* exception if this deque is empty.
402		*
403		* <p>This method is equivalent to {@link #removeFirst}.
#	Line 422 | Line 425 | public class ArrayDeque<E> extends Abstr
425
426		/**
427		* Retrieves, but does not remove, the head of the queue represented by
428	<	* this deque.  This method differs from {@link #peek} only in that it
429	<	* throws an exception if this deque is empty.
428	>	* this deque.  This method differs from {@link #peek peek} only in
429	>	* that it throws an exception if this deque is empty.
430		*
431		* <p>This method is equivalent to {@link #getFirst}.
432		*
#	Line 541 | Line 544 | public class ArrayDeque<E> extends Abstr
544		return new DeqIterator();
545		}
546
547	+	/**
548	+	* Returns an iterator over the elements in this deque in reverse
549	+	* sequential order.  The elements will be returned in order from
550	+	* last (tail) to first (head).
551	+	*
552	+	* @return an iterator over the elements in this deque in reverse
553	+	* sequence
554	+	*/
555	+	public Iterator<E> descendingIterator() {
556	+	return new DescendingIterator();
557	+	}
558	+
559		private class DeqIterator implements Iterator<E> {
560		/**
561		* Index of element to be returned by subsequent call to next.
#	Line 579 | Line 594 | public class ArrayDeque<E> extends Abstr
594		public void remove() {
595		if (lastRet < 0)
596		throw new IllegalStateException();
597	<	if (delete(lastRet))
598	<	cursor--;
597	>	if (delete(lastRet)) // if left-shifted, undo increment in next()
598	>	cursor = (cursor - 1) & (elements.length - 1);
599		lastRet = -1;
600		fence = tail;
601		}
602		}
603
604	+
605	+	private class DescendingIterator implements Iterator<E> {
606	+	/*
607	+	* This class is nearly a mirror-image of DeqIterator, using
608	+	* (tail-1) instead of head for initial cursor, (head-1)
609	+	* instead of tail for fence, and elements.length instead of -1
610	+	* for sentinel. It shares the same structure, but not many
611	+	* actual lines of code.
612	+	*/
613	+	private int cursor = (tail - 1) & (elements.length - 1);
614	+	private int fence =  (head - 1) & (elements.length - 1);
615	+	private int lastRet = elements.length;
616	+
617	+	public boolean hasNext() {
618	+	return cursor != fence;
619	+	}
620	+
621	+	public E next() {
622	+	E result;
623	+	if (cursor == fence)
624	+	throw new NoSuchElementException();
625	+	if (((head - 1) & (elements.length - 1)) != fence ||
626	+	(result = elements[cursor]) == null)
627	+	throw new ConcurrentModificationException();
628	+	lastRet = cursor;
629	+	cursor = (cursor - 1) & (elements.length - 1);
630	+	return result;
631	+	}
632	+
633	+	public void remove() {
634	+	if (lastRet >= elements.length)
635	+	throw new IllegalStateException();
636	+	if (!delete(lastRet))
637	+	cursor = (cursor + 1) & (elements.length - 1);
638	+	lastRet = elements.length;
639	+	fence = (head - 1) & (elements.length - 1);
640	+	}
641	+	}
642	+
643		/**
644		* Returns <tt>true</tt> if this deque contains the specified element.
645		* More formally, returns <tt>true</tt> if and only if this deque contains
#	Line 613 | Line 667 | public class ArrayDeque<E> extends Abstr
667		* If the deque does not contain the element, it is unchanged.
668		* More formally, removes the first element <tt>e</tt> such that
669		* <tt>o.equals(e)</tt> (if such an element exists).
670	<	* Returns true if this deque contained the specified element (or
671	<	* equivalently, if this deque changed as a result of the call).
670	>	* Returns <tt>true</tt> if this deque contained the specified element
671	>	* (or equivalently, if this deque changed as a result of the call).
672		*
673		* <p>This method is equivalent to {@link #removeFirstOccurrence}.
674		*
#	Line 645 | Line 699 | public class ArrayDeque<E> extends Abstr
699
700		/**
701		* Returns an array containing all of the elements in this deque
702	<	* in the correct order.
702	>	* in proper sequence (from first to last element).
703	>	*
704	>	* <p>The returned array will be "safe" in that no references to it are
705	>	* maintained by this deque.  (In other words, this method must allocate
706	>	* a new array).  The caller is thus free to modify the returned array.
707	>	*
708	>	* <p>This method acts as bridge between array-based and collection-based
709	>	* APIs.
710		*
711		* @return an array containing all of the elements in this deque
651	–	*         in the correct order
712		*/
713		public Object[] toArray() {
714		return copyElements(new Object[size()]);
715		}
716
717		/**
718	<	* Returns an array containing all of the elements in this deque in the
719	<	* correct order; the runtime type of the returned array is that of the
720	<	* specified array.  If the deque fits in the specified array, it is
721	<	* returned therein.  Otherwise, a new array is allocated with the runtime
722	<	* type of the specified array and the size of this deque.
723	<	*
724	<	* <p>If the deque fits in the specified array with room to spare (i.e.,
725	<	* the array has more elements than the deque), the element in the array
726	<	* immediately following the end of the collection is set to <tt>null</tt>.
718	>	* Returns an array containing all of the elements in this deque in
719	>	* proper sequence (from first to last element); the runtime type of the
720	>	* returned array is that of the specified array.  If the deque fits in
721	>	* the specified array, it is returned therein.  Otherwise, a new array
722	>	* is allocated with the runtime type of the specified array and the
723	>	* size of this deque.
724	>	*
725	>	* <p>If this deque fits in the specified array with room to spare
726	>	* (i.e., the array has more elements than this deque), the element in
727	>	* the array immediately following the end of the deque is set to
728	>	* <tt>null</tt>.
729	>	*
730	>	* <p>Like the {@link #toArray()} method, this method acts as bridge between
731	>	* array-based and collection-based APIs.  Further, this method allows
732	>	* precise control over the runtime type of the output array, and may,
733	>	* under certain circumstances, be used to save allocation costs.
734	>	*
735	>	* <p>Suppose <tt>x</tt> is a deque known to contain only strings.
736	>	* The following code can be used to dump the deque into a newly
737	>	* allocated array of <tt>String</tt>:
738	>	*
739	>	* <pre>
740	>	*     String[] y = x.toArray(new String[0]);</pre>
741	>	*
742	>	* Note that <tt>toArray(new Object[0])</tt> is identical in function to
743	>	* <tt>toArray()</tt>.
744		*
745		* @param a the array into which the elements of the deque are to
746		*          be stored, if it is big enough; otherwise, a new array of the
747		*          same runtime type is allocated for this purpose
748	<	* @return an array containing the elements of the deque
749	<	* @throws ArrayStoreException if the runtime type of a is not a supertype
750	<	*         of the runtime type of every element in this deque
748	>	* @return an array containing all of the elements in this deque
749	>	* @throws ArrayStoreException if the runtime type of the specified array
750	>	*         is not a supertype of the runtime type of every element in
751	>	*         this deque
752	>	* @throws NullPointerException if the specified array is null
753		*/
754		public <T> T[] toArray(T[] a) {
755		int size = size();

Diff Legend

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