--- jsr166/src/main/java/util/PriorityQueue.java	2003/09/12 15:38:26	1.40
+++ jsr166/src/main/java/util/PriorityQueue.java	2003/10/05 22:59:21	1.43
@@ -8,32 +8,33 @@
 package java.util;
 
 /**
- * An unbounded priority {@linkplain Queue queue} based on a priority heap.
- * This queue orders elements according to an order specified at construction
- * time, which is specified in the same manner as {@link java.util.TreeSet}
- * and {@link java.util.TreeMap}: elements are ordered either according to
- * their <i>natural order</i> (see {@link Comparable}), or according to a
- * {@link java.util.Comparator}, depending on which constructor is used.
+ * An unbounded priority {@linkplain Queue queue} based on a priority
+ * heap.  This queue orders elements according to an order specified
+ * at construction time, which is specified either according to their
+ * <i>natural order</i> (see {@link Comparable}), or according to a
+ * {@link java.util.Comparator}, depending on which constructor is
+ * used. A priority queue does not permit <tt>null</tt> elements.
+ * A priority queue relying on natural ordering also does not
+ * permit insertion of non-comparable objects (doing so may result
+ * in <tt>ClassCastException</tt>). 
  *
- * <p>The <em>head</em> of this queue is the <em>least</em> element with
- * respect to the specified ordering.  If multiple elements are tied for least
- * value, the head is one of those elements. A priority queue does not permit
- * <tt>null</tt> elements. 
+ * <p>The <em>head</em> of this queue is the <em>least</em> element
+ * with respect to the specified ordering.  If multiple elements are
+ * tied for least value, the head is one of those elements -- ties are
+ * broken arbitrarily.  The queue retrieval operations <tt>poll</tt>,
+ * <tt>remove</tt>, <tt>peek</tt>, and <tt>element</tt> access the
+ * element at the head of the queue.
  *
- * <p>The {@link #remove()} and {@link #poll()} methods remove and
- * return the head of the queue.
- *
- * <p>The {@link #element()} and {@link #peek()} methods return, but do
- * not delete, the head of the queue.
- *
- * <p>A priority queue is unbounded, but has a <i>capacity</i>.  The
- * capacity is the size of the array used internally to store the
+ * <p>A priority queue is unbounded, but has an internal
+ * <i>capacity</i> governing the size of an array used to store the
  * elements on the queue.  It is always at least as large as the queue
  * size.  As elements are added to a priority queue, its capacity
  * grows automatically.  The details of the growth policy are not
  * specified.
  *
- * <p>The Iterator provided in method {@link #iterator()} is <em>not</em>
+ * <p>This class implements all of the <em>optional</em> methods of
+ * the {@link Collection} and {@link Iterator} interfaces.  The
+ * Iterator provided in method {@link #iterator()} is <em>not</em>
  * guaranteed to traverse the elements of the PriorityQueue in any
  * particular order. If you need ordered traversal, consider using
  * <tt>Arrays.sort(pq.toArray())</tt>.
@@ -279,7 +280,7 @@ public class PriorityQueue<E> extends Ab
             
 
     /**
-     * Inserts the specified element to this priority queue.
+     * Inserts the specified element into this priority queue.
      *
      * @return <tt>true</tt>
      * @throws ClassCastException if the specified element cannot be compared
@@ -321,30 +322,7 @@ public class PriorityQueue<E> extends Ab
      * to the priority queue's ordering.
      */
     public boolean add(E o) {
-        return super.add(o);
-    }
-
-   
-    /**
-     * Adds all of the elements in the specified collection to this queue.
-     * The behavior of this operation is undefined if
-     * the specified collection is modified while the operation is in
-     * progress.  (This implies that the behavior of this call is undefined if
-     * the specified collection is this queue, and this queue is nonempty.)
-     * <p>
-     * This implementation iterates over the specified collection, and adds
-     * each object returned by the iterator to this collection, in turn.
-     * @param c collection whose elements are to be added to this queue
-     * @return <tt>true</tt> if this queue changed as a result of the
-     *         call.
-     * @throws NullPointerException if <tt>c</tt> or any element in <tt>c</tt>
-     * is <tt>null</tt>
-     * @throws ClassCastException if any element cannot be compared
-     * with elements currently in the priority queue according
-     * to the priority queue's ordering.
-     */
-    public boolean addAll(Collection<? extends E> c) {
-        return super.addAll(c);
+        return offer(o);
     }
 
     public boolean remove(Object o) {