--- jsr166/src/main/java/util/ArrayDeque.java	2016/10/23 00:28:41	1.83
+++ jsr166/src/main/java/util/ArrayDeque.java	2016/10/24 23:40:56	1.89
@@ -187,11 +187,11 @@ public class ArrayDeque<E> extends Abstr
         Object[] elements = c.toArray();
         // defend against c.toArray (incorrectly) not returning Object[]
         // (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
+        size = elements.length;
         if (elements.getClass() != Object[].class)
             elements = Arrays.copyOf(elements, size, Object[].class);
         for (Object obj : elements)
             Objects.requireNonNull(obj);
-        size = elements.length;
         this.elements = elements;
     }
 
@@ -200,7 +200,7 @@ public class ArrayDeque<E> extends Abstr
      * Precondition and postcondition: 0 <= i < modulus.
      */
     static final int inc(int i, int modulus) {
-        if (++i == modulus) i = 0;
+        if (++i >= modulus) i = 0;
         return i;
     }
 
@@ -209,7 +209,7 @@ public class ArrayDeque<E> extends Abstr
      * Precondition and postcondition: 0 <= i < modulus.
      */
     static final int dec(int i, int modulus) {
-        if (--i < 0) i += modulus;
+        if (--i < 0) i = modulus - 1;
         return i;
     }
 
@@ -234,7 +234,7 @@ public class ArrayDeque<E> extends Abstr
      * Returns element at array index i.
      */
     @SuppressWarnings("unchecked")
-    final E elementAt(int i) {
+    private E elementAt(int i) {
         return (E) elements[i];
     }
 
@@ -263,22 +263,19 @@ public class ArrayDeque<E> extends Abstr
     public void addFirst(E e) {
         // checkInvariants();
         Objects.requireNonNull(e);
-        final Object[] elements;
-        final int capacity, s;
-        if ((s = size) == (capacity = (elements = this.elements).length))
-            addFirstSlowPath(e);
-        else
-            elements[head = dec(head, capacity)] = e;
+        Object[] elements;
+        int capacity, h;
+        final int s;
+        if ((s = size) == (capacity = (elements = this.elements).length)) {
+            grow(1);
+            capacity = (elements = this.elements).length;
+        }
+        if ((h = head - 1) < 0) h = capacity - 1;
+        elements[head = h] = e;
         size = s + 1;
         // checkInvariants();
     }
 
-    private void addFirstSlowPath(E e) {
-        grow(1);
-        final Object[] elements = this.elements;
-        elements[head = dec(head, elements.length)] = e;
-    }
-
     /**
      * Inserts the specified element at the end of this deque.
      *
@@ -290,22 +287,18 @@ public class ArrayDeque<E> extends Abstr
     public void addLast(E e) {
         // checkInvariants();
         Objects.requireNonNull(e);
-        final Object[] elements;
-        final int capacity, s;
-        if ((s = size) == (capacity = (elements = this.elements).length))
-            addLastSlowPath(e);
-        else
-            elements[add(head, s, capacity)] = e;
+        Object[] elements;
+        int capacity;
+        final int s;
+        if ((s = size) == (capacity = (elements = this.elements).length)) {
+            grow(1);
+            capacity = (elements = this.elements).length;
+        }
+        elements[add(head, s, capacity)] = e;
         size = s + 1;
         // checkInvariants();
     }
 
-    private void addLastSlowPath(E e) {
-        grow(1);
-        final Object[] elements = this.elements;
-        elements[add(head, size, elements.length)] = e;
-    }
-
     /**
      * Adds all of the elements in the specified collection at the end
      * of this deque, as if by calling {@link #addLast} on each one,
@@ -317,23 +310,13 @@ public class ArrayDeque<E> extends Abstr
      * @throws NullPointerException if the specified collection or any
      *         of its elements are null
      */
-    @Override
     public boolean addAll(Collection<? extends E> c) {
+        final int s = size, needed = c.size() - (elements.length - s);
+        if (needed > 0)
+            grow(needed);
+        c.forEach((e) -> addLast(e));
         // checkInvariants();
-        Object[] a, elements;
-        int newcomers, capacity, s = size;
-        if ((newcomers = (a = c.toArray()).length) == 0)
-            return false;
-        while ((capacity = (elements = this.elements).length) - s < newcomers)
-            grow(newcomers - (capacity - s));
-        int i = add(head, s, capacity);
-        for (Object x : a) {
-            Objects.requireNonNull(x);
-            elements[i] = x;
-            i = inc(i, capacity);
-            size++;
-        }
-        return true;
+        return size > s;
     }
 
     /**
@@ -365,10 +348,10 @@ public class ArrayDeque<E> extends Abstr
      */
     public E removeFirst() {
         // checkInvariants();
-        E x = pollFirst();
-        if (x == null)
+        E e = pollFirst();
+        if (e == null)
             throw new NoSuchElementException();
-        return x;
+        return e;
     }
 
     /**
@@ -376,21 +359,22 @@ public class ArrayDeque<E> extends Abstr
      */
     public E removeLast() {
         // checkInvariants();
-        E x = pollLast();
-        if (x == null)
+        E e = pollLast();
+        if (e == null)
             throw new NoSuchElementException();
-        return x;
+        return e;
     }
 
     public E pollFirst() {
         // checkInvariants();
-        final int s, h;
+        int s, h;
         if ((s = size) == 0)
             return null;
         final Object[] elements = this.elements;
         @SuppressWarnings("unchecked") E e = (E) elements[h = head];
         elements[h] = null;
-        head = inc(h, elements.length);
+        if (++h >= elements.length) h = 0;
+        head = h;
         size = s - 1;
         return e;
     }
@@ -449,15 +433,19 @@ public class ArrayDeque<E> extends Abstr
      * @return {@code true} if the deque contained the specified element
      */
     public boolean removeFirstOccurrence(Object o) {
-        // checkInvariants();
         if (o != null) {
             final Object[] elements = this.elements;
             final int capacity = elements.length;
-            for (int k = size, i = head; --k >= 0; i = inc(i, capacity)) {
-                if (o.equals(elements[i])) {
-                    delete(i);
-                    return true;
-                }
+            int from, end, to, leftover;
+            leftover = (end = (from = head) + size)
+                - (to = (capacity - end >= 0) ? end : capacity);
+            for (;; from = 0, to = leftover, leftover = 0) {
+                for (int i = from; i < to; i++)
+                    if (o.equals(elements[i])) {
+                        delete(i);
+                        return true;
+                    }
+                if (leftover == 0) break;
             }
         }
         return false;
@@ -479,12 +467,15 @@ public class ArrayDeque<E> extends Abstr
         if (o != null) {
             final Object[] elements = this.elements;
             final int capacity = elements.length;
-            for (int k = size, i = add(head, k - 1, capacity);
-                 --k >= 0; i = dec(i, capacity)) {
-                if (o.equals(elements[i])) {
-                    delete(i);
-                    return true;
-                }
+            int from, to, end, leftover;
+            leftover = (to = ((end = (from = tail()) - size) >= -1) ? end : -1) - end;
+            for (;; from = capacity - 1, to = capacity - 1 - leftover, leftover = 0) {
+                for (int i = from; i > to; i--)
+                    if (o.equals(elements[i])) {
+                        delete(i);
+                        return true;
+                    }
+                if (leftover == 0) break;
             }
         }
         return false;
@@ -632,7 +623,7 @@ public class ArrayDeque<E> extends Abstr
                 System.arraycopy(elements, h, elements, h + 1, front - (i + 1));
             }
             elements[h] = null;
-            head = inc(h, capacity);
+            if ((head = (h + 1)) >= capacity) head = 0;
             size--;
             // checkInvariants();
             return false;
@@ -712,16 +703,17 @@ public class ArrayDeque<E> extends Abstr
         public E next() {
             if (remaining == 0)
                 throw new NoSuchElementException();
+            final Object[] elements = ArrayDeque.this.elements;
             E e = checkedElementAt(elements, cursor);
             lastRet = cursor;
-            cursor = inc(cursor, elements.length);
+            if (++cursor >= elements.length) cursor = 0;
             remaining--;
             return e;
         }
 
         void postDelete(boolean leftShifted) {
             if (leftShifted)
-                cursor = dec(cursor, elements.length); // undo inc in next
+                if (--cursor < 0) cursor = elements.length - 1;
         }
 
         public final void remove() {
@@ -732,13 +724,13 @@ public class ArrayDeque<E> extends Abstr
         }
 
         public void forEachRemaining(Consumer<? super E> action) {
-            Objects.requireNonNull(action);
-            final Object[] elements = ArrayDeque.this.elements;
-            final int capacity = elements.length;
-            int k = remaining;
-            remaining = 0;
-            for (int i = cursor; --k >= 0; i = inc(i, capacity))
-                action.accept(checkedElementAt(elements, i));
+            int k;
+            if ((k = remaining) > 0) {
+                remaining = 0;
+                ArrayDeque.forEachRemaining(action, elements, cursor, k);
+                if ((lastRet = cursor + k - 1) >= elements.length)
+                    lastRet -= elements.length;
+            }
         }
     }
 
@@ -748,26 +740,27 @@ public class ArrayDeque<E> extends Abstr
         public final E next() {
             if (remaining == 0)
                 throw new NoSuchElementException();
+            final Object[] elements = ArrayDeque.this.elements;
             E e = checkedElementAt(elements, cursor);
             lastRet = cursor;
-            cursor = dec(cursor, elements.length);
+            if (--cursor < 0) cursor = elements.length - 1;
             remaining--;
             return e;
         }
 
         void postDelete(boolean leftShifted) {
             if (!leftShifted)
-                cursor = inc(cursor, elements.length); // undo dec in next
+                if (++cursor >= elements.length) cursor = 0;
         }
 
         public final void forEachRemaining(Consumer<? super E> action) {
-            Objects.requireNonNull(action);
-            final Object[] elements = ArrayDeque.this.elements;
-            final int capacity = elements.length;
-            int k = remaining;
-            remaining = 0;
-            for (int i = cursor; --k >= 0; i = dec(i, capacity))
-                action.accept(checkedElementAt(elements, i));
+            int k;
+            if ((k = remaining) > 0) {
+                remaining = 0;
+                forEachRemainingDescending(action, elements, cursor, k);
+                if ((lastRet = cursor - (k - 1)) < 0)
+                    lastRet += elements.length;
+            }
         }
     }
 
@@ -824,13 +817,9 @@ public class ArrayDeque<E> extends Abstr
         }
 
         public void forEachRemaining(Consumer<? super E> action) {
-            Objects.requireNonNull(action);
-            final Object[] elements = ArrayDeque.this.elements;
-            final int capacity = elements.length;
-            int k = remaining();
+            int k = remaining(); // side effect!
             remaining = 0;
-            for (int i = cursor; --k >= 0; i = inc(i, capacity))
-                action.accept(checkedElementAt(elements, i));
+            ArrayDeque.forEachRemaining(action, elements, cursor, k);
         }
 
         public boolean tryAdvance(Consumer<? super E> action) {
@@ -838,7 +827,7 @@ public class ArrayDeque<E> extends Abstr
             if (remaining() == 0)
                 return false;
             action.accept(checkedElementAt(elements, cursor));
-            cursor = inc(cursor, elements.length);
+            if (++cursor >= elements.length) cursor = 0;
             remaining--;
             return true;
         }
@@ -855,18 +844,62 @@ public class ArrayDeque<E> extends Abstr
         }
     }
 
-    @Override
+    @SuppressWarnings("unchecked")
     public void forEach(Consumer<? super E> action) {
-        // checkInvariants();
         Objects.requireNonNull(action);
         final Object[] elements = this.elements;
         final int capacity = elements.length;
-        for (int k = size, i = head; --k >= 0; i = inc(i, capacity))
-            action.accept(elementAt(i));
+        int from, end, to, leftover;
+        leftover = (end = (from = head) + size)
+            - (to = (capacity - end >= 0) ? end : capacity);
+        for (;; from = 0, to = leftover, leftover = 0) {
+            for (int i = from; i < to; i++)
+                action.accept((E) elements[i]);
+            if (leftover == 0) break;
+        }
         // checkInvariants();
     }
 
     /**
+     * A variant of forEach that also checks for concurrent
+     * modification, for use in iterators.
+     */
+    static <E> void forEachRemaining(
+        Consumer<? super E> action, Object[] elements, int from, int size) {
+        Objects.requireNonNull(action);
+        final int capacity = elements.length;
+        int end, to, leftover;
+        leftover = (end = from + size)
+            - (to = (capacity - end >= 0) ? end : capacity);
+        for (;; from = 0, to = leftover, leftover = 0) {
+            for (int i = from; i < to; i++) {
+                @SuppressWarnings("unchecked") E e = (E) elements[i];
+                if (e == null)
+                    throw new ConcurrentModificationException();
+                action.accept(e);
+            }
+            if (leftover == 0) break;
+        }
+    }
+
+    static <E> void forEachRemainingDescending(
+        Consumer<? super E> action, Object[] elements, int from, int size) {
+        Objects.requireNonNull(action);
+        final int capacity = elements.length;
+        int end, to, leftover;
+        leftover = (to = ((end = from - size) >= -1) ? end : -1) - end;
+        for (;; from = capacity - 1, to = capacity - 1 - leftover, leftover = 0) {
+            for (int i = from; i > to; i--) {
+                @SuppressWarnings("unchecked") E e = (E) elements[i];
+                if (e == null)
+                    throw new ConcurrentModificationException();
+                action.accept(e);
+            }
+            if (leftover == 0) break;
+        }
+    }
+
+    /**
      * Replaces each element of this deque with the result of applying the
      * operator to that element, as specified by {@link List#replaceAll}.
      *
@@ -877,15 +910,20 @@ public class ArrayDeque<E> extends Abstr
         Objects.requireNonNull(operator);
         final Object[] elements = this.elements;
         final int capacity = elements.length;
-        for (int k = size, i = head; --k >= 0; i = inc(i, capacity))
-            elements[i] = operator.apply(elementAt(i));
+        int from, end, to, leftover;
+        leftover = (end = (from = head) + size)
+            - (to = (capacity - end >= 0) ? end : capacity);
+        for (;; from = 0, to = leftover, leftover = 0) {
+            for (int i = from; i < to; i++)
+                elements[i] = operator.apply(elementAt(i));
+            if (leftover == 0) break;
+        }
         // checkInvariants();
     }
 
     /**
      * @throws NullPointerException {@inheritDoc}
      */
-    @Override
     public boolean removeIf(Predicate<? super E> filter) {
         Objects.requireNonNull(filter);
         return bulkRemove(filter);
@@ -894,7 +932,6 @@ public class ArrayDeque<E> extends Abstr
     /**
      * @throws NullPointerException {@inheritDoc}
      */
-    @Override
     public boolean removeAll(Collection<?> c) {
         Objects.requireNonNull(c);
         return bulkRemove(e -> c.contains(e));
@@ -903,7 +940,6 @@ public class ArrayDeque<E> extends Abstr
     /**
      * @throws NullPointerException {@inheritDoc}
      */
-    @Override
     public boolean retainAll(Collection<?> c) {
         Objects.requireNonNull(c);
         return bulkRemove(e -> !c.contains(e));
@@ -916,27 +952,29 @@ public class ArrayDeque<E> extends Abstr
         final int capacity = elements.length;
         int i = head, j = i, remaining = size, deleted = 0;
         try {
-            for (; remaining > 0; remaining--, i = inc(i, capacity)) {
+            for (; remaining > 0; remaining--) {
                 @SuppressWarnings("unchecked") E e = (E) elements[i];
                 if (filter.test(e))
                     deleted++;
                 else {
                     if (j != i)
                         elements[j] = e;
-                    j = inc(j, capacity);
+                    if (++j >= capacity) j = 0;
                 }
+                if (++i >= capacity) i = 0;
             }
             return deleted > 0;
         } catch (Throwable ex) {
             if (deleted > 0)
-                for (; remaining > 0;
-                     remaining--, i = inc(i, capacity), j = inc(j, capacity))
+                for (; remaining > 0; remaining--) {
                     elements[j] = elements[i];
+                    if (++i >= capacity) i = 0;
+                    if (++j >= capacity) j = 0;
+                }
             throw ex;
         } finally {
             size -= deleted;
-            for (; --deleted >= 0; j = inc(j, capacity))
-                elements[j] = null;
+            clearSlice(elements, j, deleted);
             // checkInvariants();
         }
     }
@@ -953,9 +991,15 @@ public class ArrayDeque<E> extends Abstr
         if (o != null) {
             final Object[] elements = this.elements;
             final int capacity = elements.length;
-            for (int k = size, i = head; --k >= 0; i = inc(i, capacity))
-                if (o.equals(elements[i]))
-                    return true;
+            int from, end, to, leftover;
+            leftover = (end = (from = head) + size)
+                - (to = (capacity - end >= 0) ? end : capacity);
+            for (;; from = 0, to = leftover, leftover = 0) {
+                for (int i = from; i < to; i++)
+                    if (o.equals(elements[i]))
+                        return true;
+                if (leftover == 0) break;
+            }
         }
         return false;
     }
@@ -982,21 +1026,23 @@ public class ArrayDeque<E> extends Abstr
      * The deque will be empty after this call returns.
      */
     public void clear() {
-        final Object[] elements = this.elements;
-        final int capacity = elements.length;
-        final int h = this.head;
-        final int s = size;
-        if (capacity - h >= s)
-            Arrays.fill(elements, h, h + s, null);
-        else {
-            Arrays.fill(elements, h, capacity, null);
-            Arrays.fill(elements, 0, s - capacity + h, null);
-        }
+        clearSlice(elements, head, size);
         size = head = 0;
         // checkInvariants();
     }
 
     /**
+     * Nulls out size elements, starting at head.
+     */
+    private static void clearSlice(Object[] elements, int head, int size) {
+        final int capacity = elements.length, end = head + size;
+        final int leg = (capacity - end >= 0) ? end : capacity;
+        Arrays.fill(elements, head, leg, null);
+        if (leg != end)
+            Arrays.fill(elements, 0, end - capacity, null);
+    }
+
+    /**
      * Returns an array containing all of the elements in this deque
      * in proper sequence (from first to last element).
      *
@@ -1010,11 +1056,23 @@ public class ArrayDeque<E> extends Abstr
      * @return an array containing all of the elements in this deque
      */
     public Object[] toArray() {
-        final int head = this.head;
-        final int firstLeg;
-        Object[] a = Arrays.copyOfRange(elements, head, head + size);
-        if ((firstLeg = elements.length - head) < size)
-            System.arraycopy(elements, 0, a, firstLeg, size - firstLeg);
+        return toArray(Object[].class);
+    }
+
+    private <T> T[] toArray(Class<T[]> klazz) {
+        final Object[] elements = this.elements;
+        final int capacity = elements.length;
+        final int head = this.head, end = head + size;
+        final T[] a;
+        if (end >= 0) {
+            a = Arrays.copyOfRange(elements, head, end, klazz);
+        } else {
+            // integer overflow!
+            a = Arrays.copyOfRange(elements, 0, size, klazz);
+            System.arraycopy(elements, head, a, 0, capacity - head);
+        }
+        if (end - capacity > 0)
+            System.arraycopy(elements, 0, a, capacity - head, end - capacity);
         return a;
     }
 
@@ -1056,20 +1114,18 @@ public class ArrayDeque<E> extends Abstr
      */
     @SuppressWarnings("unchecked")
     public <T> T[] toArray(T[] a) {
+        final int size = this.size;
+        if (size > a.length)
+            return toArray((Class<T[]>) a.getClass());
         final Object[] elements = this.elements;
-        final int head = this.head;
-        final int firstLeg;
-        boolean wrap = (firstLeg = elements.length - head) < size;
-        if (size > a.length) {
-            a = (T[]) Arrays.copyOfRange(elements, head, head + size,
-                                         a.getClass());
-        } else {
-            System.arraycopy(elements, head, a, 0, wrap ? firstLeg : size);
-            if (size < a.length)
-                a[size] = null;
-        }
-        if (wrap)
-            System.arraycopy(elements, 0, a, firstLeg, size - firstLeg);
+        final int capacity = elements.length;
+        final int head = this.head, end = head + size;
+        final int front = (capacity - end >= 0) ? size : capacity - head;
+        System.arraycopy(elements, head, a, 0, front);
+        if (front != size)
+            System.arraycopy(elements, 0, a, capacity - head, end - capacity);
+        if (size < a.length)
+            a[size] = null;
         return a;
     }
 
@@ -1112,8 +1168,14 @@ public class ArrayDeque<E> extends Abstr
         // Write out elements in order.
         final Object[] elements = this.elements;
         final int capacity = elements.length;
-        for (int k = size, i = head; --k >= 0; i = inc(i, capacity))
-            s.writeObject(elements[i]);
+        int from, end, to, leftover;
+        leftover = (end = (from = head) + size)
+            - (to = (capacity - end >= 0) ? end : capacity);
+        for (;; from = 0, to = leftover, leftover = 0) {
+            for (int i = from; i < to; i++)
+                s.writeObject(elements[i]);
+            if (leftover == 0) break;
+        }
     }
 
     /**
@@ -1136,17 +1198,16 @@ public class ArrayDeque<E> extends Abstr
     }
 
     /** debugging */
-    private void checkInvariants() {
+    void checkInvariants() {
         try {
             int capacity = elements.length;
-            assert size >= 0 && size <= capacity;
-            assert head >= 0 && ((capacity == 0 && head == 0 && size == 0)
-                                 || head < capacity);
-            assert size == 0
-                || (elements[head] != null && elements[tail()] != null);
-            assert size == capacity
-                || (elements[dec(head, capacity)] == null
-                    && elements[inc(tail(), capacity)] == null);
+            // assert size >= 0 && size <= capacity;
+            // assert head >= 0;
+            // assert capacity == 0 || head < capacity;
+            // assert size == 0 || elements[head] != null;
+            // assert size == 0 || elements[tail()] != null;
+            // assert size == capacity || elements[dec(head, capacity)] == null;
+            // assert size == capacity || elements[inc(tail(), capacity)] == null;
         } catch (Throwable t) {
             System.err.printf("head=%d size=%d capacity=%d%n",
                               head, size, elements.length);