--- jsr166/src/jsr166x/ArrayDeque.java	2004/12/05 21:15:30	1.1
+++ jsr166/src/jsr166x/ArrayDeque.java	2010/09/01 05:20:40	1.5
@@ -34,7 +34,7 @@ import java.io.*;
  * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
  * as it is, generally speaking, impossible to make any hard guarantees in the
  * presence of unsynchronized concurrent modification.  Fail-fast iterators
- * throw <tt>ConcurrentModificationException</tt> on a best-effort basis. 
+ * throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
  * Therefore, it would be wrong to write a program that depended on this
  * exception for its correctness: <i>the fail-fast behavior of iterators
  * should be used only to detect bugs.</i>
@@ -90,7 +90,7 @@ public class ArrayDeque<E> extends Abstr
      *
      * @param numElements  the number of elements to hold.
      */
-    private void allocateElements(int numElements) {   
+    private void allocateElements(int numElements) {
         int initialCapacity = MIN_INITIAL_CAPACITY;
         // Find the best power of two to hold elements.
         // Tests "<=" because arrays aren't kept full.
@@ -114,7 +114,7 @@ public class ArrayDeque<E> extends Abstr
      * when head and tail have wrapped around to become equal.
      */
     private void doubleCapacity() {
-        assert head == tail; 
+        assert head == tail;
         int p = head;
         int n = elements.length;
         int r = n - p; // number of elements to the right of p
@@ -194,7 +194,7 @@ public class ArrayDeque<E> extends Abstr
         if (e == null)
             throw new NullPointerException();
         elements[head = (head - 1) & (elements.length - 1)] = e;
-        if (head == tail) 
+        if (head == tail)
             doubleCapacity();
     }
 
@@ -243,7 +243,7 @@ public class ArrayDeque<E> extends Abstr
         E result = elements[t];
         if (result == null)
             return null;
-        elements[t] = null; 
+        elements[t] = null;
         tail = t;
         return result;
     }
@@ -332,7 +332,7 @@ public class ArrayDeque<E> extends Abstr
      * @return the first element of this deque
      * @throws NoSuchElementException if this deque is empty
      */
-    public E firstElement() {
+    public E getFirst() {
         E x = elements[head];
         if (x == null)
             throw new NoSuchElementException();
@@ -347,7 +347,7 @@ public class ArrayDeque<E> extends Abstr
      * @return the last element of this deque
      * @throws NoSuchElementException if this deque is empty
      */
-    public E lastElement() {
+    public E getLast() {
         E x = elements[(tail - 1) & (elements.length - 1)];
         if (x == null)
             throw new NoSuchElementException();
@@ -478,13 +478,13 @@ public class ArrayDeque<E> extends Abstr
      * this deque.  This method differs from the <tt>peek</tt> method only in
      * that it throws an exception if this deque is empty.
      *
-     * <p>This method is equivalent to {@link #firstElement}
+     * <p>This method is equivalent to {@link #getFirst}
      *
      * @return the head of the queue represented by this deque
      * @throws NoSuchElementException if this deque is empty
      */
     public E element() {
-        return firstElement();
+        return getFirst();
     }
 
     // *** Stack methods ***
@@ -504,7 +504,7 @@ public class ArrayDeque<E> extends Abstr
 
     /**
      * Pops an element from the stack represented by this deque.  In other
-     * words, removes and returns the the first element of this deque.
+     * words, removes and returns the first element of this deque.
      *
      * <p>This method is equivalent to {@link #removeFirst()}.
      *
@@ -523,7 +523,7 @@ public class ArrayDeque<E> extends Abstr
      *
      * <p>This method is called delete rather than remove to emphasize the
      * that that its semantics differ from those of List.remove(int).
-     * 
+     *
      * @return true if elements moved backwards
      */
     private boolean delete(int i) {
@@ -568,7 +568,7 @@ public class ArrayDeque<E> extends Abstr
      * will be ordered from first (head) to last (tail).  This is the same
      * order that elements would be dequeued (via successive calls to
      * {@link #remove} or popped (via successive calls to {@link #pop}).
-     * 
+     *
      * @return an <tt>Iterator</tt> over the elements in this deque
      */
     public Iterator<E> iterator() {
@@ -676,10 +676,10 @@ public class ArrayDeque<E> extends Abstr
      * in the correct order.
      *
      * @return an array containing all of the elements in this list
-     * 	       in the correct order
+     *         in the correct order
      */
     public Object[] toArray() {
-	return copyElements(new Object[size()]);
+        return copyElements(new Object[size()]);
     }
 
     /**
@@ -694,8 +694,8 @@ public class ArrayDeque<E> extends Abstr
      * immediately following the end of the collection is set to <tt>null</tt>.
      *
      * @param a the array into which the elements of the deque are to
-     *		be stored, if it is big enough; otherwise, a new array of the
-     * 		same runtime type is allocated for this purpose
+     *          be stored, if it is big enough; otherwise, a new array of the
+     *          same runtime type is allocated for this purpose
      * @return an array containing the elements of the deque
      * @throws ArrayStoreException if the runtime type of a is not a supertype
      *         of the runtime type of every element in this deque
@@ -705,7 +705,7 @@ public class ArrayDeque<E> extends Abstr
         if (a.length < size)
             a = (T[])java.lang.reflect.Array.newInstance(
                     a.getClass().getComponentType(), size);
-	copyElements(a);
+        copyElements(a);
         if (a.length > size)
             a[size] = null;
         return a;
@@ -719,14 +719,14 @@ public class ArrayDeque<E> extends Abstr
      * @return a copy of this deque
      */
     public ArrayDeque<E> clone() {
-        try { 
+        try {
             ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
             // These two lines are currently faster than cloning the array:
             result.elements = (E[]) new Object[elements.length];
             System.arraycopy(elements, 0, result.elements, 0, elements.length);
             return result;
 
-        } catch (CloneNotSupportedException e) { 
+        } catch (CloneNotSupportedException e) {
             throw new AssertionError();
         }
     }