2006-09-05 Andrew John Hughes <gnu_andrew@member.fsf.org>

	* Merge of HEAD-->generics from 2006/08/12 to 2006/09/03.

3 files changed, 87 insertions, 26 deletions

diff --git a/java/lang/management/ManagementFactory.java b/java/lang/management/ManagementFactory.java
index d6727ea10..d9a02ee23 100644
--- a/java/lang/management/ManagementFactory.java
+++ b/java/lang/management/ManagementFactory.java
@@ -67,6 +67,49 @@ import javax.management.NotCompliantMBeanException;
  * <li>Calling the appropriate static method of this factory.
  * </li>
  * </ol>
+ * <h2>Open Data Types</h2>
+ * <p>
+ * The data types used by the management beans are restricted
+ * to <emph>open</emph> data types to aid interoperability.  This
+ * allows the beans to be accessed remotely, including from non-Java
+ * clients.  Below is a table which lists the types used by the beans
+ * on the left, and the types they are converted to when returned via
+ * a bean server on the right.  Type information is provided for each
+ * bean by obtaining its instance of {@link javax.management.MBeanInfo}.
+ * </p>
+ * <table>
+ * <th><td>Data Type Used</td><td>Data Type Returned</td></th>
+ * <tr>
+ * <td>Primitive types (<code>int</code>, <code>char</code>, etc.)</td>
+ * <td>Same</td>
+ * </tr><tr>
+ * <td>Wrapper classes ({@link{java.lang.Integer},
+ * @link{java.lang.Character}, etc.)</td>
+ * <td>Same</td>
+ * </tr><tr>
+ * <td>An {@link java.lang.Enum}</td>
+ * <td>The <code>name</code> of the enumeration constant</td>
+ * </tr><tr>
+ * <td>An array of type <code>E</code></td>
+ * <td>An array of the same dimensions with this mapping applied
+ * to <code>E</code>.</td>
+ * </tr><tr>
+ * <td>A class with `getter' methods and a
+ * <code>from({@link javax.management.openmbean.CompositeData})</code>
+ * method.</td>
+ * <td>The equivalent {@link javax.management.openmbean.CompositeData}
+ * instance, specified by the <code>from</code> method.</td>
+ * </tr><tr>
+ * <td>A map with keys of type <code>K</code> and values of
+ * type <code>V</code>.</td>
+ * <td>A {@link javax.management.openmbean.TabularData} instance,
+ * with the row type containing two items, <code>"key"</code> and
+ * <code>"value"</code> with the types <code>K</code> and <code>V</code>
+ * respectively (with translation applied).</td>
+ * </tr><tr>
+ * <td>A list of type <code>E</code>.</td>
+ * <td>An array with this mapping applied to <code>E</code>.</td>
+ * </tr></table>
  *
  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  * @since 1.5
diff --git a/java/lang/ref/Reference.java b/java/lang/ref/Reference.java
index 8a7501863..ce224b891 100644
--- a/java/lang/ref/Reference.java
+++ b/java/lang/ref/Reference.java
@@ -1,5 +1,5 @@
 /* java.lang.ref.Reference
-   Copyright (C) 1999, 2002, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2002, 2003, 2004, 2006 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -82,7 +82,7 @@ public abstract class Reference<T>
    * The queue this reference is registered on. This is null, if this
    * wasn't registered to any queue or reference was already enqueued.
    */
-  ReferenceQueue<? super T> queue;
+  volatile ReferenceQueue<? super T> queue;
 
   /**
    * Link to the next entry on the queue.  If this is null, this
@@ -91,7 +91,7 @@ public abstract class Reference<T>
    * (not to null, that value is used to mark a not enqueued
    * reference).  
    */
-  Reference nextOnQueue;
+  volatile Reference nextOnQueue;
 
   /**
    * This lock should be taken by the garbage collector, before
@@ -166,11 +166,10 @@ public abstract class Reference<T>
    */
   public boolean enqueue() 
   {
-    if (queue != null && nextOnQueue == null)
+    ReferenceQueue q = queue;
+    if (q != null)
       {
-	queue.enqueue(this);
-	queue = null;
-	return true;
+	return q.enqueue(this);
       }
     return false;
   }
diff --git a/java/lang/ref/ReferenceQueue.java b/java/lang/ref/ReferenceQueue.java
index 189b81b17..281628779 100644
--- a/java/lang/ref/ReferenceQueue.java
+++ b/java/lang/ref/ReferenceQueue.java
@@ -1,5 +1,5 @@
 /* java.lang.ref.ReferenceQueue
-   Copyright (C) 1999, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2004, 2006 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -63,6 +63,12 @@ public class ReferenceQueue<T>
   private Reference<? extends T> first;
 
   /**
+   * This is the lock that protects our linked list and is used to signal
+   * a thread waiting in remove().
+   */
+  private final Object lock = new Object();
+
+  /**
    * Creates a new empty reference queue.
    */
   public ReferenceQueue()
@@ -76,7 +82,7 @@ public class ReferenceQueue<T>
    * @return a reference on the queue, if there is one,
    * <code>null</code> otherwise.  
    */
-  public synchronized Reference<? extends T> poll()
+  public Reference<? extends T> poll()
   { 
     return dequeue();
   }
@@ -84,14 +90,23 @@ public class ReferenceQueue<T>
   /**
    * This is called by reference to enqueue itself on this queue.  
    * @param ref the reference that should be enqueued.
+   * @return true if successful, false if not.
    */
-  synchronized void enqueue(Reference<? extends T> ref)
-  {
-    /* last reference will point to itself */
-    ref.nextOnQueue = first == null ? ref : first;
-    first = ref;
-    /* this wakes only one remove thread. */
-    notify();
+  final boolean enqueue(Reference<? extends T> ref)
+    {
+    synchronized (lock)
+      {
+        if (ref.queue != this)
+          return false;
+
+        /* last reference will point to itself */
+        ref.nextOnQueue = first == null ? ref : first;
+        ref.queue = null;
+        first = ref;
+        /* this wakes only one remove thread. */
+        lock.notify();
+        return true;
+      }
   }
 
   /**
@@ -100,13 +115,16 @@ public class ReferenceQueue<T>
    */
   private Reference<? extends T> dequeue()
   {
-    if (first == null)
-      return null;
-
-    Reference<? extends T> result = first;
-    first = (first == first.nextOnQueue) ? null : first.nextOnQueue;
-    result.nextOnQueue = null;
-    return result;
+    synchronized (lock)
+      {
+        if (first == null)
+          return null;
+  
+        Reference<? extends T> result = first;
+        first = (first == first.nextOnQueue) ? null : first.nextOnQueue;
+        result.nextOnQueue = null;
+        return result;
+      }
   }
 
   /**
@@ -118,12 +136,13 @@ public class ReferenceQueue<T>
    * <code>null</code> if timeout period expired.  
    * @exception InterruptedException if the wait was interrupted.
    */
-  public synchronized Reference<? extends T> remove(long timeout)
+  public Reference<? extends T> remove(long timeout)
     throws InterruptedException
   {
-    if (first == null)
+    synchronized (lock)
       {
-	wait(timeout);
+        if (first == null)
+          lock.wait(timeout);
       }
 
     return dequeue();