ViewVC Help

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

root/jsr166/jsr166/src/jsr166x/ArrayDeque.java

Comparing jsr166/src/jsr166x/ArrayDeque.java (file contents):
Revision 1.2 by dl, Sun Dec 26 20:13:15 2004 UTC vs.
Revision 1.3 by jsr166, Mon Nov 16 04:16:42 2009 UTC

#	Line 34 | Line 34 | import java.io.*;
34		* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
35		* as it is, generally speaking, impossible to make any hard guarantees in the
36		* presence of unsynchronized concurrent modification.  Fail-fast iterators
37	<	* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
37	>	* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
38		* Therefore, it would be wrong to write a program that depended on this
39		* exception for its correctness: <i>the fail-fast behavior of iterators
40		* should be used only to detect bugs.</i>
#	Line 90 | Line 90 | public class ArrayDeque<E> extends Abstr
90		*
91		* @param numElements  the number of elements to hold.
92		*/
93	<	private void allocateElements(int numElements) {
93	>	private void allocateElements(int numElements) {
94		int initialCapacity = MIN_INITIAL_CAPACITY;
95		// Find the best power of two to hold elements.
96		// Tests "<=" because arrays aren't kept full.
#	Line 114 | Line 114 | public class ArrayDeque<E> extends Abstr
114		* when head and tail have wrapped around to become equal.
115		*/
116		private void doubleCapacity() {
117	<	assert head == tail;
117	>	assert head == tail;
118		int p = head;
119		int n = elements.length;
120		int r = n - p; // number of elements to the right of p
#	Line 194 | Line 194 | public class ArrayDeque<E> extends Abstr
194		if (e == null)
195		throw new NullPointerException();
196		elements[head = (head - 1) & (elements.length - 1)] = e;
197	<	if (head == tail)
197	>	if (head == tail)
198		doubleCapacity();
199		}
200
#	Line 243 | Line 243 | public class ArrayDeque<E> extends Abstr
243		E result = elements[t];
244		if (result == null)
245		return null;
246	<	elements[t] = null;
246	>	elements[t] = null;
247		tail = t;
248		return result;
249		}
#	Line 523 | Line 523 | public class ArrayDeque<E> extends Abstr
523		*
524		* <p>This method is called delete rather than remove to emphasize the
525		* that that its semantics differ from those of List.remove(int).
526	<	*
526	>	*
527		* @return true if elements moved backwards
528		*/
529		private boolean delete(int i) {
#	Line 568 | Line 568 | public class ArrayDeque<E> extends Abstr
568		* will be ordered from first (head) to last (tail).  This is the same
569		* order that elements would be dequeued (via successive calls to
570		* {@link #remove} or popped (via successive calls to {@link #pop}).
571	<	*
571	>	*
572		* @return an <tt>Iterator</tt> over the elements in this deque
573		*/
574		public Iterator<E> iterator() {
#	Line 719 | Line 719 | public class ArrayDeque<E> extends Abstr
719		* @return a copy of this deque
720		*/
721		public ArrayDeque<E> clone() {
722	<	try {
722	>	try {
723		ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
724		// These two lines are currently faster than cloning the array:
725		result.elements = (E[]) new Object[elements.length];
726		System.arraycopy(elements, 0, result.elements, 0, elements.length);
727		return result;
728
729	<	} catch (CloneNotSupportedException e) {
729	>	} catch (CloneNotSupportedException e) {
730		throw new AssertionError();
731		}
732		}

Diff Legend

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