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

Comparing jsr166/src/main/java/util/concurrent/ConcurrentLinkedDeque.java (file contents):
Revision 1.63 by jsr166, Fri Feb 20 03:09:08 2015 UTC vs.
Revision 1.64 by jsr166, Sat Feb 21 17:15:00 2015 UTC

# Line 12 | Line 12 | import java.util.Collection;
12   import java.util.Deque;
13   import java.util.Iterator;
14   import java.util.NoSuchElementException;
15 + import java.util.Objects;
16   import java.util.Queue;
17   import java.util.Spliterator;
18   import java.util.Spliterators;
# Line 319 | Line 320 | public class ConcurrentLinkedDeque<E>
320       * Links e as first element.
321       */
322      private void linkFirst(E e) {
323 <        checkNotNull(e);
323 <        final Node<E> newNode = new Node<E>(e);
323 >        final Node<E> newNode = new Node<E>(Objects.requireNonNull(e));
324  
325          restartFromHead:
326          for (;;)
# Line 352 | Line 352 | public class ConcurrentLinkedDeque<E>
352       * Links e as last element.
353       */
354      private void linkLast(E e) {
355 <        checkNotNull(e);
356 <        final Node<E> newNode = new Node<E>(e);
355 >        final Node<E> newNode = new Node<E>(Objects.requireNonNull(e));
356  
357          restartFromTail:
358          for (;;)
# Line 758 | Line 757 | public class ConcurrentLinkedDeque<E>
757      // Minor convenience utilities
758  
759      /**
761 –     * Throws NullPointerException if argument is null.
762 –     *
763 –     * @param v the element
764 –     */
765 –    private static void checkNotNull(Object v) {
766 –        if (v == null)
767 –            throw new NullPointerException();
768 –    }
769 –
770 –    /**
760       * Returns element unless it is null, in which case throws
761       * NoSuchElementException.
762       *
# Line 800 | Line 789 | public class ConcurrentLinkedDeque<E>
789          // Copy c into a private chain of Nodes
790          Node<E> h = null, t = null;
791          for (E e : c) {
792 <            checkNotNull(e);
804 <            Node<E> newNode = new Node<E>(e);
792 >            Node<E> newNode = new Node<E>(Objects.requireNonNull(e));
793              if (h == null)
794                  h = t = newNode;
795              else {
# Line 1011 | Line 999 | public class ConcurrentLinkedDeque<E>
999       * @throws NullPointerException if the specified element is null
1000       */
1001      public boolean removeFirstOccurrence(Object o) {
1002 <        checkNotNull(o);
1002 >        Objects.requireNonNull(o);
1003          for (Node<E> p = first(); p != null; p = succ(p)) {
1004              E item = p.item;
1005              if (item != null && o.equals(item) && p.casItem(item, null)) {
# Line 1035 | Line 1023 | public class ConcurrentLinkedDeque<E>
1023       * @throws NullPointerException if the specified element is null
1024       */
1025      public boolean removeLastOccurrence(Object o) {
1026 <        checkNotNull(o);
1026 >        Objects.requireNonNull(o);
1027          for (Node<E> p = last(); p != null; p = pred(p)) {
1028              E item = p.item;
1029              if (item != null && o.equals(item) && p.casItem(item, null)) {
# Line 1142 | Line 1130 | public class ConcurrentLinkedDeque<E>
1130          // Copy c into a private chain of Nodes
1131          Node<E> beginningOfTheEnd = null, last = null;
1132          for (E e : c) {
1133 <            checkNotNull(e);
1146 <            Node<E> newNode = new Node<E>(e);
1133 >            Node<E> newNode = new Node<E>(Objects.requireNonNull(e));
1134              if (beginningOfTheEnd == null)
1135                  beginningOfTheEnd = last = newNode;
1136              else {

Diff Legend

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