* Makefile.am: Add HashSet.java and java/lang/ref classes.

	Remove BasicMapEntry.java and Bucket.java.
	* Makefile.in: Rebuilt.
	* java/util/HashMap.java: Rewritten.
	* java/util/HashSet.java: Imported from classpath.
	* java/util/WeakHashMap.java: Imported from classpath.
	* java/util/Hashtable.java: Rewritten based on new HashMap code.
	* java/util/Bucket.java: Deleted.
	* java/util/BasicMapEntry.java: Deleted.
	* java/util/Collections.java (search): Use a for-loop, not iterator
	hasNext().
	(copy): Use a for-loop. Throw an IndexOutOfBoundsException if run out
	of elements in source.
	(max): Use a for-loop.
	(min): Ditto.
	(reverse): Keep track of positions instead of using Iterator's
	nextIndex() and previousIndex().
	(shuffle(List)): Initialize defaultRandom if required using
	double-check thread safety idiom. Call two-argument shuffle method
	using defaultRandom.
	(defaultRandom): New field.
	(shuffle(List, Random)): Use a for-loop. Keep track of pos instead
	of using previousIndex() and nextIndex().
	(singletonMap(iterator)): Use a HashMap.Entry, not BasicMapEntry.
	* java/util/AbstractCollection.java (toString): Use a StringBuffer.
	* java/util/AbstractMap.java (toString): Use StringBuffer.
	* java/lang/ref/PhantomReference.java: Imported from classpath.
	* java/lang/ref/SoftReference.java: Ditto.
	* java/lang/ref/Reference.java: Ditto.
	* java/lang/ref/WeakReference.java: Ditto.
	* java/lang/ref/ReferenceQueue.java: Ditto.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@38183 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 134 insertions, 0 deletions

diff --git a/libjava/java/lang/ref/ReferenceQueue.java b/libjava/java/lang/ref/ReferenceQueue.java
new file mode 100644
index 00000000000..57ec4193db1
--- /dev/null
+++ b/libjava/java/lang/ref/ReferenceQueue.java
@@ -0,0 +1,134 @@
+/* java.lang.ref.ReferenceQueue
+   Copyright (C) 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+ 
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package java.lang.ref;
+
+/**
+ * This is the queue, where references can enqueue themselve on.  Each
+ * reference may be registered to a queue at initialization time and
+ * will be appended to the queue, when the enqueue method is called.
+ *
+ * The enqueue method may be automatically called by the garbage
+ * collector if it detects, that the object is only reachable through
+ * the Reference objects.
+ *
+ * @author Jochen Hoenicke
+ * @see Reference#enqueue()
+ */
+public class ReferenceQueue
+{
+  /**
+   * This is a linked list of references.  If this is null, the list is
+   * empty.  Otherwise this points to the first reference on the queue.
+   * The first reference will point to the next reference via the 
+   * <code>nextOnQueue</code> field.  The last reference will point to
+   * itself (not to null, since <code>nextOnQueue</code> is used to 
+   * determine if a reference is enqueued).
+   */
+  private Reference first;
+
+  /**
+   * Creates a new empty reference queue.
+   */
+  public ReferenceQueue()
+  {
+  }
+
+  /**
+   * Checks if there is a reference on the queue, returning it
+   * immediately.  The reference will be dequeued.
+   *
+   * @return a reference on the queue, if there is one,
+   * <code>null</code> otherwise.  
+   */
+  public synchronized Reference poll()
+  { 
+    return dequeue();
+  }
+
+  /**
+   * This is called by reference to enqueue itself on this queue.  
+   * @param ref the reference that should be enqueued.
+   */
+  synchronized void enqueue(Reference ref)
+  {
+    /* last reference will point to itself */
+    ref.nextOnQueue = first == null ? ref : first;
+    first = ref;
+    /* this wakes only one remove thread. */
+    notify();
+  }
+
+  /**
+   * Remove a reference from the queue, if there is one.
+   * @return the first element of the queue, or null if there isn't any.
+   */
+  private Reference dequeue()
+  {
+    if (first == null)
+      return null;
+
+    Reference result = first;
+    first = (first == first.nextOnQueue) ? null : first.nextOnQueue;
+    result.nextOnQueue = null;
+    return result;
+  }
+
+  /**
+   * Removes a reference from the queue, blocking for <code>timeout</code>
+   * until a reference is enqueued.
+   * @param timeout the timeout period in milliseconds, <code>0</code> means
+   * wait forever.
+   * @return the reference removed from the queue, or 
+   * <code>null</code> if timeout period expired.  
+   * @exception InterruptedException if the wait was interrupted.
+   */
+  public synchronized Reference remove(long timeout)
+    throws InterruptedException
+  {
+    if (first == null)
+      {
+	wait(timeout);
+      }
+
+    return dequeue();
+  }
+    
+
+  /**
+   * Removes a reference from the queue, blocking until a reference is
+   * enqueued.
+   *
+   * @return the reference removed from the queue.  
+   * @exception InterruptedException if the wait was interrupted.
+   */
+  public Reference remove()
+    throws InterruptedException
+  {
+    return remove(0L);
+  }
+}