--- jsr166/src/jsr166y/LinkedTransferQueue.java	2009/07/24 23:48:26	1.25
+++ jsr166/src/jsr166y/LinkedTransferQueue.java	2009/07/27 03:21:19	1.29
@@ -5,11 +5,16 @@
  */
 
 package jsr166y;
+
 import java.util.concurrent.*;
-import java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
-import java.util.*;
-import java.io.*;
+
+import java.util.AbstractQueue;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.concurrent.locks.LockSupport;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
 /**
  * An unbounded {@linkplain TransferQueue} based on linked nodes.
@@ -437,12 +442,20 @@ public class LinkedTransferQueue<E> exte
         addAll(c);
     }
 
+    /**
+     * @throws InterruptedException {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     */
     public void put(E e) throws InterruptedException {
         if (e == null) throw new NullPointerException();
         if (Thread.interrupted()) throw new InterruptedException();
         xfer(e, NOWAIT, 0);
     }
 
+    /**
+     * @throws InterruptedException {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     */
     public boolean offer(E e, long timeout, TimeUnit unit)
         throws InterruptedException {
         if (e == null) throw new NullPointerException();
@@ -451,18 +464,28 @@ public class LinkedTransferQueue<E> exte
         return true;
     }
 
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     */
     public boolean offer(E e) {
         if (e == null) throw new NullPointerException();
         xfer(e, NOWAIT, 0);
         return true;
     }
 
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     */
     public boolean add(E e) {
         if (e == null) throw new NullPointerException();
         xfer(e, NOWAIT, 0);
         return true;
     }
 
+    /**
+     * @throws InterruptedException {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     */
     public void transfer(E e) throws InterruptedException {
         if (e == null) throw new NullPointerException();
         if (xfer(e, WAIT, 0) == null) {
@@ -471,6 +494,10 @@ public class LinkedTransferQueue<E> exte
         }
     }
 
+    /**
+     * @throws InterruptedException {@inheritDoc}
+     * @throws NullPointerException {@inheritDoc}
+     */
     public boolean tryTransfer(E e, long timeout, TimeUnit unit)
         throws InterruptedException {
         if (e == null) throw new NullPointerException();
@@ -481,11 +508,17 @@ public class LinkedTransferQueue<E> exte
         throw new InterruptedException();
     }
 
+    /**
+     * @throws NullPointerException {@inheritDoc}
+     */
     public boolean tryTransfer(E e) {
         if (e == null) throw new NullPointerException();
         return fulfill(e) != null;
     }
 
+    /**
+     * @throws InterruptedException {@inheritDoc}
+     */
     public E take() throws InterruptedException {
         Object e = xfer(null, WAIT, 0);
         if (e != null)
@@ -494,6 +527,9 @@ public class LinkedTransferQueue<E> exte
         throw new InterruptedException();
     }
 
+    /**
+     * @throws InterruptedException {@inheritDoc}
+     */
     public E poll(long timeout, TimeUnit unit) throws InterruptedException {
         Object e = xfer(null, TIMEOUT, unit.toNanos(timeout));
         if (e != null || !Thread.interrupted())
@@ -505,6 +541,10 @@ public class LinkedTransferQueue<E> exte
         return fulfill(null);
     }
 
+    /**
+     * @throws NullPointerException    {@inheritDoc}
+     * @throwsIllegalArgumentException {@inheritDoc}
+     */
     public int drainTo(Collection<? super E> c) {
         if (c == null)
             throw new NullPointerException();
@@ -519,6 +559,10 @@ public class LinkedTransferQueue<E> exte
         return n;
     }
 
+    /**
+     * @throws NullPointerException    {@inheritDoc}
+     * @throwsIllegalArgumentException {@inheritDoc}
+     */
     public int drainTo(Collection<? super E> c, int maxElements) {
         if (c == null)
             throw new NullPointerException();
@@ -794,16 +838,47 @@ public class LinkedTransferQueue<E> exte
                                  new PaddedAtomicReference<Node<E>>(null));
     }
 
-    // Unsafe mechanics for jsr166y 3rd party package.
+    // Unsafe mechanics
+
+    private static final sun.misc.Unsafe UNSAFE = getUnsafe();
+    private static final long headOffset =
+        objectFieldOffset("head", LinkedTransferQueue.class);
+    private static final long tailOffset =
+        objectFieldOffset("tail", LinkedTransferQueue.class);
+    private static final long cleanMeOffset =
+        objectFieldOffset("cleanMe", LinkedTransferQueue.class);
+
+    private static long objectFieldOffset(String field, Class<?> klazz) {
+        try {
+            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
+        } catch (NoSuchFieldException e) {
+            // Convert Exception to corresponding Error
+            NoSuchFieldError error = new NoSuchFieldError(field);
+            error.initCause(e);
+            throw error;
+        }
+    }
+
+    /**
+     * Returns a sun.misc.Unsafe.  Suitable for use in a 3rd party package.
+     * Replace with a simple call to Unsafe.getUnsafe when integrating
+     * into a jdk.
+     *
+     * @return a sun.misc.Unsafe
+     */
     private static sun.misc.Unsafe getUnsafe() {
         try {
             return sun.misc.Unsafe.getUnsafe();
         } catch (SecurityException se) {
             try {
                 return java.security.AccessController.doPrivileged
-                    (new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
+                    (new java.security
+                     .PrivilegedExceptionAction<sun.misc.Unsafe>() {
                         public sun.misc.Unsafe run() throws Exception {
-                            return getUnsafeByReflection();
+                            java.lang.reflect.Field f = sun.misc
+                                .Unsafe.class.getDeclaredField("theUnsafe");
+                            f.setAccessible(true);
+                            return (sun.misc.Unsafe) f.get(null);
                         }});
             } catch (java.security.PrivilegedActionException e) {
                 throw new RuntimeException("Could not initialize intrinsics",
@@ -811,32 +886,4 @@ public class LinkedTransferQueue<E> exte
             }
         }
     }
-
-    private static sun.misc.Unsafe getUnsafeByReflection()
-            throws NoSuchFieldException, IllegalAccessException {
-        java.lang.reflect.Field f =
-            sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
-        f.setAccessible(true);
-        return (sun.misc.Unsafe) f.get(null);
-    }
-
-    private static long fieldOffset(String fieldName, Class<?> klazz) {
-        try {
-            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(fieldName));
-        } catch (NoSuchFieldException e) {
-            // Convert Exception to Error
-            NoSuchFieldError error = new NoSuchFieldError(fieldName);
-            error.initCause(e);
-            throw error;
-        }
-    }
-
-    private static final sun.misc.Unsafe UNSAFE = getUnsafe();
-    static final long headOffset =
-        fieldOffset("head", LinkedTransferQueue.class);
-    static final long tailOffset =
-        fieldOffset("tail", LinkedTransferQueue.class);
-    static final long cleanMeOffset =
-        fieldOffset("cleanMe", LinkedTransferQueue.class);
-
 }