ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/ArrayDeque.java
(Generate patch)

Comparing jsr166/src/main/java/util/ArrayDeque.java (file contents):
Revision 1.32 by jsr166, Wed Jun 8 00:21:52 2011 UTC vs.
Revision 1.36 by jsr166, Fri Dec 2 15:51:56 2011 UTC

# Line 63 | Line 63 | public class ArrayDeque<E> extends Abstr
63       * other.  We also guarantee that all array cells not holding
64       * deque elements are always null.
65       */
66 <    private transient E[] elements;
66 >    private transient Object[] elements;
67  
68      /**
69       * The index of the element at the head of the deque (which is the
# Line 107 | Line 107 | public class ArrayDeque<E> extends Abstr
107              if (initialCapacity < 0)   // Too many elements, must back off
108                  initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
109          }
110 <        elements = (E[]) new Object[initialCapacity];
110 >        elements = new Object[initialCapacity];
111      }
112  
113      /**
# Line 125 | Line 125 | public class ArrayDeque<E> extends Abstr
125          Object[] a = new Object[newCapacity];
126          System.arraycopy(elements, p, a, 0, r);
127          System.arraycopy(elements, 0, a, r, p);
128 <        elements = (E[])a;
128 >        elements = a;
129          head = 0;
130          tail = n;
131      }
# Line 153 | Line 153 | public class ArrayDeque<E> extends Abstr
153       * sufficient to hold 16 elements.
154       */
155      public ArrayDeque() {
156 <        elements = (E[]) new Object[16];
156 >        elements = new Object[16];
157      }
158  
159      /**
# Line 261 | Line 261 | public class ArrayDeque<E> extends Abstr
261  
262      public E pollFirst() {
263          int h = head;
264 <        E result = elements[h]; // Element is null if deque empty
264 >        @SuppressWarnings("unchecked") E result = (E) elements[h];
265 >        // Element is null if deque empty
266          if (result == null)
267              return null;
268          elements[h] = null;     // Must null out slot
# Line 271 | Line 272 | public class ArrayDeque<E> extends Abstr
272  
273      public E pollLast() {
274          int t = (tail - 1) & (elements.length - 1);
275 <        E result = elements[t];
275 >        @SuppressWarnings("unchecked") E result = (E) elements[t];
276          if (result == null)
277              return null;
278          elements[t] = null;
# Line 283 | Line 284 | public class ArrayDeque<E> extends Abstr
284       * @throws NoSuchElementException {@inheritDoc}
285       */
286      public E getFirst() {
287 <        E x = elements[head];
288 <        if (x == null)
287 >        @SuppressWarnings("unchecked") E result = (E) elements[head];
288 >        if (result == null)
289              throw new NoSuchElementException();
290 <        return x;
290 >        return result;
291      }
292  
293      /**
294       * @throws NoSuchElementException {@inheritDoc}
295       */
296      public E getLast() {
297 <        E x = elements[(tail - 1) & (elements.length - 1)];
298 <        if (x == null)
297 >        @SuppressWarnings("unchecked")
298 >        E result = (E) elements[(tail - 1) & (elements.length - 1)];
299 >        if (result == null)
300              throw new NoSuchElementException();
301 <        return x;
301 >        return result;
302      }
303  
304 +    @SuppressWarnings("unchecked")
305      public E peekFirst() {
306 <        return elements[head]; // elements[head] is null if deque empty
306 >        // elements[head] is null if deque empty
307 >        return (E) elements[head];
308      }
309  
310 +    @SuppressWarnings("unchecked")
311      public E peekLast() {
312 <        return elements[(tail - 1) & (elements.length - 1)];
312 >        return (E) elements[(tail - 1) & (elements.length - 1)];
313      }
314  
315      /**
# Line 324 | Line 329 | public class ArrayDeque<E> extends Abstr
329              return false;
330          int mask = elements.length - 1;
331          int i = head;
332 <        E x;
332 >        Object x;
333          while ( (x = elements[i]) != null) {
334              if (o.equals(x)) {
335                  delete(i);
# Line 352 | Line 357 | public class ArrayDeque<E> extends Abstr
357              return false;
358          int mask = elements.length - 1;
359          int i = (tail - 1) & mask;
360 <        E x;
360 >        Object x;
361          while ( (x = elements[i]) != null) {
362              if (o.equals(x)) {
363                  delete(i);
# Line 497 | Line 502 | public class ArrayDeque<E> extends Abstr
502       */
503      private boolean delete(int i) {
504          checkInvariants();
505 <        final E[] elements = this.elements;
505 >        final Object[] elements = this.elements;
506          final int mask = elements.length - 1;
507          final int h = head;
508          final int t = tail;
# Line 595 | Line 600 | public class ArrayDeque<E> extends Abstr
600          public E next() {
601              if (cursor == fence)
602                  throw new NoSuchElementException();
603 <            E result = elements[cursor];
603 >            @SuppressWarnings("unchecked") E result = (E) elements[cursor];
604              // This check doesn't catch all possible comodifications,
605              // but does catch the ones that corrupt traversal
606              if (tail != fence || result == null)
# Line 634 | Line 639 | public class ArrayDeque<E> extends Abstr
639              if (cursor == fence)
640                  throw new NoSuchElementException();
641              cursor = (cursor - 1) & (elements.length - 1);
642 <            E result = elements[cursor];
642 >            @SuppressWarnings("unchecked") E result = (E) elements[cursor];
643              if (head != fence || result == null)
644                  throw new ConcurrentModificationException();
645              lastRet = cursor;
# Line 665 | Line 670 | public class ArrayDeque<E> extends Abstr
670              return false;
671          int mask = elements.length - 1;
672          int i = head;
673 <        E x;
673 >        Object x;
674          while ( (x = elements[i]) != null) {
675              if (o.equals(x))
676                  return true;
# Line 748 | Line 753 | public class ArrayDeque<E> extends Abstr
753       * The following code can be used to dump the deque into a newly
754       * allocated array of <tt>String</tt>:
755       *
756 <     * <pre>
752 <     *     String[] y = x.toArray(new String[0]);</pre>
756 >     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
757       *
758       * Note that <tt>toArray(new Object[0])</tt> is identical in function to
759       * <tt>toArray()</tt>.
# Line 763 | Line 767 | public class ArrayDeque<E> extends Abstr
767       *         this deque
768       * @throws NullPointerException if the specified array is null
769       */
770 +    @SuppressWarnings("unchecked")
771      public <T> T[] toArray(T[] a) {
772          int size = size();
773          if (a.length < size)
# Line 783 | Line 788 | public class ArrayDeque<E> extends Abstr
788       */
789      public ArrayDeque<E> clone() {
790          try {
791 +            @SuppressWarnings("unchecked")
792              ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
793              result.elements = Arrays.copyOf(elements, elements.length);
794              return result;
789 –
795          } catch (CloneNotSupportedException e) {
796              throw new AssertionError();
797          }
# Line 832 | Line 837 | public class ArrayDeque<E> extends Abstr
837  
838          // Read in all elements in the proper order.
839          for (int i = 0; i < size; i++)
840 <            elements[i] = (E)s.readObject();
840 >            elements[i] = s.readObject();
841      }
842   }

Diff Legend

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