obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

25 files changed, 6214 insertions, 0 deletions

diff --git a/libjava/classpath/javax/management/openmbean/ArrayType.java b/libjava/classpath/javax/management/openmbean/ArrayType.java
new file mode 100644
index 000000000..fc1887014
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/ArrayType.java
@@ -0,0 +1,672 @@
+/* ArrayType.java -- Open type descriptor for an array.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.lang.reflect.Array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The open type descriptor for arrays of open data values.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class ArrayType<T>
+  extends OpenType<T>
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 720504429830309770L;
+
+  /**
+   * The number of dimensions arrays of this type has.
+   */
+  private int dimension;
+
+  /**
+   * The element type of arrays of this type.
+   */
+  private OpenType<?> elementType;
+
+  /**
+   * True if this type represents a primitive array.
+   */
+  private boolean primitiveArray;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * A cache of {@link ArrayType} instances created
+   * by {@link #getArrayType(OpenType)}.
+   */
+  private static final Map<OpenType<?>,ArrayType<?>> cache =
+    new HashMap<OpenType<?>,ArrayType<?>>();
+
+  /**
+   * A cache of {@link ArrayType} instances created
+   * by {@link #getPrimitiveArrayType(Class)}.
+   */
+  private static final Map<Class<?>,ArrayType<?>> primCache =
+    new HashMap<Class<?>,ArrayType<?>>();
+
+  /**
+   * Returns the class name of the array, given the element
+   * class name and its dimensions.
+   *
+   * @param elementType the type of the array's elements.
+   * @param dim the dimensions of the array.
+   * @param primitive true if this should be a primitive array.
+   * @return the array's class name.
+   * @throws OpenDataException if the class name does not reference
+   *                           a loadable class.
+   */
+  private static final String getArrayClassName(OpenType<?> elementType,
+                                                int dim,
+                                                boolean primitive)
+    throws OpenDataException
+  {
+    Class<?> type;
+    if (primitive)
+      type = getPrimitiveTypeClass((SimpleType<?>) elementType);
+    else
+      {
+        String className = elementType.getClassName();
+        try
+          {
+            type = Class.forName(className);
+          }
+        catch (ClassNotFoundException e)
+          {
+            throw new OpenDataException("The class name, " + className +
+                                        ", is unavailable.");
+          }
+      }
+    while (type.isArray())
+      type = type.getComponentType();
+    return
+      Array.newInstance(type,
+                        new int[getDimensions(elementType, dim)]).getClass().getName();
+  }
+
+  /**
+   * Returns the dimensions of the new {@link ArrayType},
+   * based on whether the given element type is already an
+   * {@link ArrayType} or not.
+   *
+   * @param elementType the type of the array.
+   * @param dim the proposed dimensions.
+   * @return the resultant dimensions.
+   * @throws IllegalArgumentException if <code>dim</code> is less than 1.
+   */
+  private static final int getDimensions(OpenType<?> elementType,
+                                         int dim)
+  {
+    if (dim < 1)
+      throw new IllegalArgumentException("Dimensions must be greater " +
+                                         "than or equal to 1.");
+    if (elementType instanceof ArrayType)
+      return dim + ((ArrayType<?>) elementType).getDimension();
+    return dim;
+  }
+
+  /**
+   * Returns the appropriate primitive type name, given the
+   * corresponding wrapper class.
+   *
+   * @param type the type to convert.
+   * @return the corresponding primitive type.
+   * @throws OpenDataException if {@code type} is not a valid
+   *                           {@link Class} for a primitive type.
+   *
+   */
+  private static final SimpleType<?> getPrimitiveType(Class<?> type)
+    throws OpenDataException
+  {
+    if (type.equals(Boolean.TYPE))
+      return SimpleType.BOOLEAN;
+    if (type.equals(Byte.TYPE))
+      return SimpleType.BYTE;
+    if (type.equals(Character.TYPE))
+      return SimpleType.CHARACTER;
+    if (type.equals(Double.TYPE))
+      return SimpleType.DOUBLE;
+    if (type.equals(Float.TYPE))
+      return SimpleType.FLOAT;
+    if (type.equals(Integer.TYPE))
+      return SimpleType.INTEGER;
+    if (type.equals(Long.TYPE))
+      return SimpleType.LONG;
+    if (type.equals(Short.TYPE))
+      return SimpleType.SHORT;
+    if (type.equals(Void.TYPE))
+      return SimpleType.VOID;
+    throw new OpenDataException(type + " is not a primitive type.");
+  }
+
+  /**
+   * Returns the appropriate primitive type name, given the
+   * corresponding wrapper class.
+   *
+   * @param type the type to convert.
+   * @return the corresponding primitive type.
+   * @throws OpenDataException if {@code type} is not a valid
+   *                           {@link SimpleType} for a primitive type.
+   *
+   */
+  private static final Class<?> getPrimitiveTypeClass(SimpleType<?> type)
+    throws OpenDataException
+  {
+    if (type.equals(SimpleType.BOOLEAN))
+      return Boolean.TYPE;
+    if (type.equals(SimpleType.BYTE))
+      return Byte.TYPE;
+    if (type.equals(SimpleType.CHARACTER))
+      return Character.TYPE;
+    if (type.equals(SimpleType.DOUBLE))
+      return Double.TYPE;
+    if (type.equals(SimpleType.FLOAT))
+      return Float.TYPE;
+    if (type.equals(SimpleType.INTEGER))
+      return Integer.TYPE;
+    if (type.equals(SimpleType.LONG))
+      return Long.TYPE;
+    if (type.equals(SimpleType.SHORT))
+      return Short.TYPE;
+    if (type.equals(SimpleType.VOID))
+      return Void.TYPE;
+    throw new OpenDataException(type + " is not a primitive type.");
+  }
+
+  /**
+   * Returns the element type that will actually be used, if the
+   * specified element type is passed to a constructor.  This is
+   * necessary to ensure that a non-array type is still returned when
+   * an {@link ArrayType} is constructed from an {@link ArrayType}.
+   *
+   * @param elemType the element type that was supplied.
+   * @return the element type that will be used.
+   */
+  private static final OpenType<?> getElementType(OpenType<?> elemType)
+  {
+    if (elemType instanceof ArrayType)
+      return ((ArrayType<?>) elemType).getElementOpenType();
+    return elemType;
+  }
+
+  /**
+   * Returns the element type name that will actually be used, if the
+   * specified element type is passed to a constructor.  This is
+   * necessary to ensure that a non-array type is still returned when
+   * an {@link ArrayType} is constructed from an {@link ArrayType},
+   * and that primitive arrays are described correctly.
+   *
+   * @param elemType the element type that was supplied.
+   * @return the element type name that will be used.
+   * @throws OpenDataException if the element type is not a valid
+   *                           {@link SimpleType} for a primitive type.
+   */
+  private static final String getElementTypeName(OpenType<?> elemType)
+    throws OpenDataException
+  {
+    OpenType<?> trueElemType = getElementType(elemType);
+    if (elemType instanceof ArrayType &&
+        ((ArrayType<?>) elemType).isPrimitiveArray())
+      return getPrimitiveTypeClass((SimpleType<?>) trueElemType).getName();
+    return trueElemType.getClassName();
+  }
+
+  /**
+   * <p>
+   * Constructs a new {@link ArrayType} instance for an array of the
+   * specified type with the supplied number of dimensions.  The attributes
+   * used by the superclass, {@link OpenType}, are automatically defined,
+   * based on these values.  Both the class name and type name are set
+   * to the value returned by the {@link java.lang.Class#getName()} of
+   * the array's class (i.e. the element type, preceded by n instances of
+   * '[' and an 'L', where n is the number of dimensions the array has).
+   * The description is based upon the template <code>n-dimension array
+   * of e</code>, where n is the number of dimensions of the array, and
+   * e is the element type.  The class name of the actual elements is
+   * obtainable by calling {@link OpenType#getClassName()} on the result
+   * of {@link #getElementOpenType()}.
+   * </p>
+   * <p>
+   * As an example, the array type returned by
+   * <code>new ArrayType(6, SimpleType.INTEGER)</code> has the following
+   * values:
+   * </p>
+   * <table>
+   * <th><td>Attribute</td><td>Value</td></th>
+   * <tr><td>Class Name</td><td><code>[[[[[[Ljava.lang.Integer;</code>
+   * </td></tr>
+   * <tr><td>Type Name</td><td><code>[[[[[[Ljava.lang.Integer;</code>
+   * </td></tr>
+   * <tr><td>Description</td><td><code>6-dimension array of
+   * java.lang.Integer</code></td></tr>
+   * <tr><td>Element Type Class Name</td><td><code>java.lang.Integer</code>
+   * </td></tr>
+   * </table>
+   * <p>
+   * The dimensions of the array must be equal to or greater than 1.  The
+   * element type must be an instance of {@link SimpleType},
+   * {@link CompositeType} or {@link TabularType}.
+   * </p>
+   *
+   * @param dim the dimensions of the array.
+   * @param elementType the type of the elements of the array.
+   * @throws IllegalArgumentException if <code>dim</code> is less than 1.
+   * @throws OpenDataException if the element type is not an instance of either
+   *                           {@link SimpleType}, {@link CompositeType}
+   *                           or {@link TabularType}.
+   */
+  public ArrayType(int dim, OpenType<?> elementType)
+    throws OpenDataException
+  {
+    super(getArrayClassName(elementType, dim, false),
+          getArrayClassName(elementType, dim, false),
+          getDimensions(elementType, dim) + "-dimension array of "
+          + getElementTypeName(elementType));
+    if (!(elementType instanceof SimpleType ||
+          elementType instanceof CompositeType ||
+          elementType instanceof TabularType ||
+          elementType instanceof ArrayType))
+      throw new OpenDataException("The element type must be a simple " +
+                                  "type, an array type, a composite type " +
+                                  "or a tabular type.");
+    dimension = getDimensions(elementType, dim);
+    this.elementType = getElementType(elementType);
+    primitiveArray = (elementType instanceof ArrayType &&
+                      ((ArrayType<?>) elementType).isPrimitiveArray());
+  }
+
+  /**
+   * <p>
+   * Constructs a new {@link ArrayType} instance for a unidimensional
+   * array of the specified {@link SimpleType}.  The attributes
+   * used by the superclass, {@link OpenType}, are automatically defined,
+   * based on these values.  Both the class name and type name are set
+   * to the value returned by the {@link java.lang.Class#getName()} of
+   * the array's class.  If the array is of a primitive type (indicated
+   * by giving {@code primitiveArray} the value {@code true}), the
+   * name will be '[' followed by the appropriate letter for the
+   * primitive type (see {@link java.lang.Class#getName()}).  If the
+   * array is not of a primitive type, then the name is formed from
+   * the element type, preceded by '[' and an 'L', in the same way
+   * as when the multi-dimensional constructor is used.
+   * </p>
+   * <p>
+   * The description is based upon the template <code>1-dimension array
+   * of e</code>, where e is either the primitive type or a class name,
+   * depending on whether the array itself is of a primitive type or not.
+   * The class name of the actual elements is obtainable by calling
+   * {@link OpenType#getClassName()} on the result of
+   * {@link #getElementOpenType()}.  This will be the appropriate wrapper
+   * class for a primitive type.
+   * </p>
+   * <p>
+   * As an example, the array type returned by
+   * <code>new ArrayType(SimpleType.INTEGER, true)</code> has the following
+   * values:
+   * </p>
+   * <table>
+   * <th><td>Attribute</td><td>Value</td></th>
+   * <tr><td>Class Name</td><td><code>[I</code>
+   * </td></tr>
+   * <tr><td>Type Name</td><td><code>[I</code>
+   * </td></tr>
+   * <tr><td>Description</td><td><code>1-dimension array of int</code></td></tr>
+   * <tr><td>Element Type Class Name</td><td><code>java.lang.Integer</code>
+   * </td></tr>
+   * </table>
+   *
+   * @param elementType the type of the elements of the array.
+   * @param primitiveArray true if the array should be of a primitive type.
+   * @throws OpenDataException if {@code primitiveArray} is {@code true},
+   *                           and {@link elementType} is not a valid
+   *                           {@link SimpleType} for a primitive type.
+   * @since 1.6
+   */
+  public ArrayType(SimpleType<?> elementType, boolean primitiveArray)
+    throws OpenDataException
+  {
+    super(getArrayClassName(elementType, 1, primitiveArray),
+          getArrayClassName(elementType, 1, primitiveArray),
+          "1-dimension array of " +
+          (primitiveArray ? getPrimitiveTypeClass(elementType).getName()
+           : elementType.getClassName()));
+    dimension = 1;
+    this.elementType = elementType;
+    this.primitiveArray = primitiveArray;
+  }
+
+  /**
+   * <p>
+   * Compares this array type with another object
+   * for equality.  The objects are judged to be equal if:
+   * </p>
+   * <ul>
+   * <li><code>obj</code> is not null.</li>
+   * <li><code>obj</code> is an instance of
+   * {@link ArrayType}.</li>
+   * <li>The dimensions are equal.</li>
+   * <li>The element types are equal.</li>
+   * <li>The primitive array flag is set the same in both
+   * instances.</li>
+   * </ul>
+   *
+   * @param obj the object to compare with.
+   * @return true if the conditions above hold.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof ArrayType))
+      return false;
+    ArrayType<?> atype = (ArrayType<?>) obj;
+    return (atype.getDimension() == dimension &&
+            atype.getElementOpenType().equals(elementType) &&
+            atype.isPrimitiveArray() == primitiveArray);
+  }
+
+  /**
+   * <p>
+   * Returns a new {@link ArrayType} instance in a type-safe
+   * manner, by ensuring that the type of the given {@link OpenType}
+   * matches the component type used in the type of the
+   * returned instance.  If the given {@link OpenType} is a
+   * {@link SimpleType}, {@link CompositeType} or
+   * {@link TabularType}, then a 1-dimensional array of that
+   * type is returned.  Otherwise, if the type is
+   * an {@link ArrayType} of n dimensions, the returned
+   * type is also an {@link ArrayType} but of n+1 dimensions.
+   * For example,
+   * {@code ArrayType.getArrayType(ArrayType.getArrayType(SimpleType.STRING))}
+   * returns a 2-dimensional array of {@link SimpleType#String}.
+   * </p>
+   * <p>
+   * This method caches its results, so that the same instance
+   * is returned from subsequent calls with the same parameters.
+   * </p>
+   *
+   * @param elementType the element type of the new array type.
+   * @throws OpenDataException if the class name of {@code elementType}
+   *                           is not in {@link OpenType#ALLOWED_CLASSNAMES_LIST}.
+   * @since 1.6
+   */
+  @SuppressWarnings("unchecked")
+  public static <E> ArrayType<E[]> getArrayType(OpenType<E> elementType)
+    throws OpenDataException
+  {
+    ArrayType<E[]> arr = (ArrayType<E[]>) cache.get(elementType);
+    if (arr != null)
+      return arr;
+    arr = new ArrayType<E[]>(1, elementType);
+    cache.put(elementType, arr);
+    return arr;
+  }
+
+  /**
+   * <p>
+   * Returns a new {@link ArrayType} instance for the given
+   * primitive type in a type-safe* manner, by ensuring that
+   * the type of the given {@link OpenType} matches the type
+   * used in the returned instance.  If the type is
+   * an array of n dimensions, the returned
+   * type is also an {@link ArrayType} of n dimensions.
+   * </p>
+   * <p>
+   * As an example, the array type returned by
+   * <code>getPrimitiveArrayType(Integer.TYPE)</code> has the
+   * following values:
+   * </p>
+   * <table>
+   * <th><td>Attribute</td><td>Value</td></th>
+   * <tr><td>Class Name</td><td><code>[I</code>
+   * </td></tr>
+   * <tr><td>Type Name</td><td><code>[I</code>
+   * </td></tr>
+   * <tr><td>Description</td><td><code>1-dimension array of int</code></td></tr>
+   * <tr><td>Element Type Class Name</td><td><code>java.lang.Integer</code>
+   * </td></tr>
+   * </table>
+   * <p>
+   * This method caches its results, so that the same instance
+   * is returned from subsequent calls with the same parameters.
+   * </p>
+   *
+   * @param type the type of the new {@link ArrayType}.
+   * @throws IllegalArgumentException if the type is not a primitive
+   *                                  array.
+   * @since 1.6
+   */
+  @SuppressWarnings("unchecked")
+  public static <T> ArrayType<T> getPrimitiveArrayType(Class<T> type)
+  {
+    ArrayType<T> arr = (ArrayType<T>) primCache.get(type);
+    if (arr != null)
+      return arr;
+    Class<?> comType = type;
+    int dim = 0;
+    do
+      {
+        comType = comType.getComponentType();
+        ++dim;
+        if (comType == null)
+          throw new IllegalArgumentException("The given class is " +
+                                             "not an array.");
+      } while (comType.isArray());
+    try
+      {
+        arr = new ArrayType<T>(getPrimitiveType(comType), true);
+      }
+    catch (OpenDataException e)
+      {
+        throw new IllegalArgumentException("The array is not of a primitive " +
+                                           "type", e);
+      }
+    while (dim > 1)
+      try
+        {
+          arr = new ArrayType<T>(1, arr);
+          --dim;
+        }
+      catch (OpenDataException e)
+        {
+          throw (Error)
+            new InternalError("Couldn't generate extra dimensions").initCause(e);
+        }
+    primCache.put(type, arr);
+    return arr;
+  }
+
+  /**
+   * Returns the number of dimensions used by arrays
+   * of this type.
+   *
+   * @return the number of dimensions.
+   */
+  public int getDimension()
+  {
+    return dimension;
+  }
+
+  /**
+   * Returns the open type descriptor which describes
+   * the type of the elements of this array type.
+   *
+   * @return the type of the elements.
+   */
+  public OpenType<?> getElementOpenType()
+  {
+    return elementType;
+  }
+
+  /**
+   * <p>
+   * Returns the hash code of the array type.
+   * This is computed as the sum of the hash code of the
+   * element type together with the number of dimensions
+   * the array has and the primitive array flag.  These
+   * are the same elements of the type that are compared as
+   * part of the {@link #equals(java.lang.Object)} method,
+   * thus ensuring that the hashcode is compatible with the
+   * equality test.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the hash code
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hash code of this instance.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode = Integer.valueOf(dimension +
+                                 elementType.hashCode() +
+                                 Boolean.valueOf(primitiveArray).hashCode());
+    return hashCode.intValue();
+  }
+
+  /**
+   * Returns true if this instance represents an array of
+   * a primitive type.
+   *
+   * @return true if the array is of a primitive type.
+   */
+  public boolean isPrimitiveArray()
+  {
+    return primitiveArray;
+  }
+
+  /**
+   * <p>
+   * Returns true if the specified object is a member of this
+   * array type.  The object is judged to be so if it is
+   * non-null, an array and one of the following two conditions
+   * holds:
+   * </p>
+   * <ul>
+   * <li>This {@link ArrayType} instance has a {@link SimpleType}
+   * as its element type.  Thus, the object must have the same
+   * class name as that returned by {@link SimpleType#getClassName()}
+   * for this class.</li>
+   * <li>This {@link ArrayType} instance has a {@link CompositeType}
+   * or a {@link TabularType} as its element type.  Thus, the object
+   * must be assignable to such an array, and have elements which
+   * are either null or valid values for the element type.</li>
+   * </ul>
+   *
+   * @param obj the object to test for membership.
+   * @return true if the object is a member of this type.
+   */
+  public boolean isValue(Object obj)
+  {
+    if (obj == null)
+      return false;
+    Class<?> objClass = obj.getClass();
+    if (!(objClass.isArray()))
+      return false;
+    if (elementType instanceof SimpleType)
+      return getClassName().equals(objClass.getName());
+    Class<?> elementClass = null;
+    try
+      {
+        elementClass = Class.forName(getClassName());
+      }
+    catch (ClassNotFoundException e)
+      {
+        throw new IllegalStateException("The array type's element " +
+                                        "class could not be found.", e);
+      }
+    if (!(elementClass.isAssignableFrom(objClass)))
+      return false;
+    for (int a = 0; a < Array.getLength(obj); ++a)
+      {
+        Object elem = Array.get(obj, a);
+        if (elem != null &&
+            (!(elementType.isValue(elem))))
+          return false;
+      }
+    return true;
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.ArrayType</code>)
+   * and each element of the instance which is relevant to
+   * the definition of {@link equals(java.lang.Object)} and
+   * {@link hashCode()} (i.e. the type name, the number of
+   * dimensions and the element type).
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getTypeName()
+        + ", dimension=" + dimension
+        + ", elementType=" + elementType
+        + ", primitiveArray=" + primitiveArray
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/CompositeData.java b/libjava/classpath/javax/management/openmbean/CompositeData.java
new file mode 100644
index 000000000..c3d2b2d9d
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/CompositeData.java
@@ -0,0 +1,153 @@
+/* CompositeData.java -- A composite data structure.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Collection;
+
+/**
+ * Provides an interface to a composite data structure,
+ * in order to aid interoperability.  The composite data
+ * structure is represented by mapping field names to
+ * values.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface CompositeData
+{
+
+  /**
+   * Returns true if this {@link CompositeData} instance contains
+   * the specified key.  This method always returns false for
+   * an input key equal to <code>null</code> or the empty string.
+   *
+   * @param key the key to find in the structure.
+   * @return true if the key exists.
+   */
+  boolean containsKey(String key);
+
+  /**
+   * Returns true if this {@link CompositeData} instance has
+   * a value equal to that supplied.
+   *
+   * @param value the value to look for.
+   * @return true if the value exists.
+   */
+  boolean containsValue(Object value);
+
+  /**
+   * Compares the specified object with this object for equality.
+   * The object is judged equivalent if it is non-null, and also
+   * an instance of {@link CompositeData} with the same name-value
+   * mappings and types.  The two compared instances may be
+   * equivalent even if they represent different implementations of
+   * {@link CompositeData}.
+   *
+   * @param obj the object to compare for equality.
+   * @return true if <code>obj</code> is equal to <code>this</code>.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Retrieves the value for the specified key.
+   *
+   * @param key the key whose value should be returned.
+   * @return the matching value.
+   * @throws IllegalArgumentException if the key is <code>null</code>
+   *                                  or the empty string.
+   * @throws InvalidKeyException if the key does not exist.
+   */
+  Object get(String key);
+
+  /**
+   * Returns the appropriate value for each key in the given array,
+   * using the same ordering.
+   *
+   * @param keys the keys whose values should be returned.
+   * @return the matching values.
+   * @throws IllegalArgumentException if one of the keys is
+   *                                  <code>null</code> or the
+   *                                  empty string.
+   * @throws InvalidKeyException if one of the keys does not exist.
+   */
+  Object[] getAll(String[] keys);
+
+  /**
+   * Returns the composite type which corresponds to this instance
+   * of {@link CompositeData}.
+   *
+   * @return the composite type for this instance.
+   */
+  CompositeType getCompositeType();
+
+  /**
+   * Returns the hash code of this instance.  The hash code is
+   * computed as the sum of the hash codes of all the values plus
+   * the hash code of the composite type.  As equality comparisons
+   * take place using this same information, this ensures that
+   * the property, <code>e1.equals(e2)</code> implies
+   * <code>e1.hashCode() == e2.hashCode(), holds for any pair
+   * of instances, <code>e1</code> and <code>e2</code>.
+   *
+   * @return the hash code of this {@link CompositeData}.
+   * @see Object#equals(Object)
+   */
+  int hashCode();
+
+  /**
+   * Returns a textual representation of this instance.  The
+   * exact format is left up to the implementation, but it
+   * should contain the name of the implementing class,
+   * the name of the type and a mapping of the form
+   * <code>key=value</code> for each pair of key and value.
+   *
+   * @return a {@link java.lang.String} representation of the
+   *         object.
+   */
+  String toString();
+
+  /**
+   * Returns a read-only collection of the values associated with
+   * this instance.  The values are sorted using the lexicographic
+   * ordering of the corresponding keys.
+   *
+   * @return the values of this instance.
+   */
+  Collection<?> values();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/CompositeDataInvocationHandler.java b/libjava/classpath/javax/management/openmbean/CompositeDataInvocationHandler.java
new file mode 100644
index 000000000..4f10f6ea2
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/CompositeDataInvocationHandler.java
@@ -0,0 +1,190 @@
+/* CompositeDataInvocationHandler.java - Pseudo-accessors for CompositeData.
+   Copyright (C) 2007 Free Software Foundation
+
+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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+/**
+ * <p>
+ * Provides an {@link java.lang.reflect.InvocationHandler} which
+ * implements a series of accessor methods (those beginning with
+ * {@code "get"} or {@code "is"}) using the content of a
+ * {@link CompositeData} object.  An instance of {@link CompositeData}
+ * consists of a series of key-value mappings.  This handler assumes
+ * these keys to be the names of attributes, and thus provides
+ * accessor methods by returning the associated value.
+ * </p>
+ * <p>
+ * As an example, consider the following interface:
+ * </p>
+ * <pre>
+ * public interface Person
+ * {
+ *   public String getName();
+ *   public Date getBirthday();
+ * }
+ * </pre>
+ * <p>
+ * This specifies two accessor methods for retrieving the attributes,
+ * {@code name} and {@code birthday}.  An implementation of this interface
+ * can be provided by creating an instance of this class, using a
+ * {@link CompositeData} object with appropriate key-value mappings
+ * (e.g. "name" => "Fred", "birthday" => 30/06/1974), and then passing
+ * that to {@link java.lang.reflect.Proxy#newProxyInstance} along with
+ * the interface itself.  The invocation handler implements the methods
+ * by calling {@link CompositeData#get(String)} with the appropriate key.
+ * </p>
+ * <p>
+ * The attribute name is derived by taking the remainder of the method
+ * name following {@code "get"}.  If the first letter of this substring
+ * is uppercase, then two attempts are made to retrieve the attribute
+ * from the {@link CompositeData} instance: one using the original substring,
+ * and one with the first letter changed to its lower-case equivalent.
+ * If the first letter is lowercase, only the exact substring is used.
+ * </p>
+ * <p>
+ * An {@link Object#equals(Object)} implementation is provided.  This returns
+ * true if the argument is a proxy with a {@link CompositeDataInvocationHandler}
+ * using an equivalent {@link CompositeData} instance.  {@link Object#hashCode()}
+ * is also defined so as to match this implementation and give equivalent instances
+ * the same hashcode.
+ * </p>
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.6
+ */
+public class CompositeDataInvocationHandler
+  implements InvocationHandler
+{
+
+  /**
+   * The {@link CompositeData} providing the key-value mappings.
+   */
+  private CompositeData data;
+
+  /**
+   * Constructs a new {@link CompositeDataInvocationHandler}
+   * with the specified {@link CompositeData} instance.
+   *
+   * @param data the {@link CompositeData} instance to use.
+   * @throws IllegalArgumentException if {@code data} is {@code null}.
+   */
+  public CompositeDataInvocationHandler(CompositeData data)
+  {
+    if (data == null)
+      throw new IllegalArgumentException("The CompositeData instance " +
+                                         "must be non-null.");
+    this.data = data;
+  }
+
+  /**
+   * Returns the {@link CompositeData} instance which provides
+   * the key-value mappings for this instance.  This is never
+   * {@code null}.
+   *
+   * @return the {@link CompositeData} instance.
+   */
+  public CompositeData getCompositeData()
+  {
+    return data;
+  }
+
+  /**
+   * Called by the proxy class whenever a method is called.  The
+   * handler only deals with accessor methods (beginning with
+   * {@code "get"} or {@code "is"}), {@code equals}, and
+   * {@code "hashCode"}.  Accessor methods are implemented by
+   * returning the appropriate value from the {@link CompositeData}
+   * instance, while {@code equals} and {@code hashCode} allow
+   * two proxies with a {@link CompositeDataInvocationHandler} using
+   * the same {@link CompositeData} instance to be classified
+   * as equivalent.
+   *
+   * @param proxy the proxy on which the method was called.
+   * @param method the method which was called.
+   * @param args the arguments supplied to the method.
+   * @return the return value from the method.
+   * @throws Throwable if an exception is thrown in the process.
+   */
+  public Object invoke(Object proxy, Method method, Object[] args)
+    throws Throwable
+  {
+    String mName = method.getName();
+    if (mName.equals("equals"))
+      {
+        if (args[0] instanceof Proxy)
+          {
+            InvocationHandler h = Proxy.getInvocationHandler(args[0]);
+            if (h instanceof CompositeDataInvocationHandler)
+              return data.equals(((CompositeDataInvocationHandler)
+                                  h).getCompositeData());
+          }
+        return false;
+      }
+    if (mName.equals("hashCode"))
+      {
+        return data.hashCode();
+      }
+    String attrib = null;
+    if (mName.startsWith("get"))
+      attrib = mName.substring(3);
+    else if (mName.startsWith("is"))
+      attrib = mName.substring(2);
+    if (attrib == null)
+      throw new NoSuchMethodException(mName + " is not an accessor.");
+    if (!data.containsKey(attrib))
+      {
+        if (Character.isLowerCase(attrib.charAt(0)))
+          throw new NoSuchMethodException("The attribute " +
+                                          attrib + " is not available " +
+                                          "in the given CompositeData " +
+                                          "object");
+        attrib = Character.toLowerCase(attrib.charAt(0))
+          + attrib.substring(1);
+        if (!data.containsKey(attrib))
+          throw new NoSuchMethodException("The attribute " +
+                                          attrib + " is not available " +
+                                          "in the given CompositeData " +
+                                          "object");
+      }
+    return data.get(attrib);
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/CompositeDataSupport.java b/libjava/classpath/javax/management/openmbean/CompositeDataSupport.java
new file mode 100644
index 000000000..2cc6f4049
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/CompositeDataSupport.java
@@ -0,0 +1,345 @@
+/* CompositeData.java -- A composite data structure implementation.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.io.Serializable;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * Provides an implementation of the {@link CompositeData}
+ * interface.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class CompositeDataSupport
+  implements CompositeData, Serializable
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 8003518976613702244L;
+
+  /**
+   * Mapping of field names to values.
+   *
+   * @serial the map of field names to values.
+   */
+  private SortedMap<String, Object> contents;
+
+  /**
+   * The composite type which represents this composite data instance.
+   *
+   * @serial the type information for this instance.
+   */
+  private CompositeType compositeType;
+
+  /**
+   * Constructs a new {@link CompositeDataSupport} instance with the
+   * specified type using field names and values from the supplied map.
+   * The keys of the map become the field names, while the values
+   * become the values of each respective field.  This constructor simply
+   * calls the other constructor, with the two arrays formed using the
+   * keys and values of this map, respectively.  Thus, the input parameters
+   * given should conform to the same requirements given there (i.e. no
+   * null values or empty strings).
+   *
+   * @param type the composite type of this composite data structure.
+   * @param items a mapping of field names to values.  This should match
+   *              the mappings given by the type (i.e. for each mapping
+   *              in the type, there should be a corresponding field name
+   *              with a value of the correct type).
+   * @throws IllegalArgumentException if the type, the map or any of the keys
+   *                                  or values in the map are <code>null</code>,
+   *                                  or if any key from the map is an empty
+   *                                  string.
+   * @throws OpenDataException if a mismatch occurs between the map and the
+   *                           field name/type specification given by the
+   *                           {@link CompositeType} instance.  This may be
+   *                           due to the two having a different size, a
+   *                           mismatch between keys or an incorrectly typed
+   *                           value.
+   * @throws ArrayStoreException if one of the keys is not a
+   *                             {@link java.lang.String} (thus calling a failure
+   *                             in converting the keys to an array of strings).
+   */
+  public CompositeDataSupport(CompositeType type, Map<String, ?> items)
+    throws OpenDataException
+  {
+    this(type,
+         items.keySet().toArray(new String[items.size()]),
+         items.values().toArray());
+  }
+
+  /**
+   * Constructs a new {@link CompositeDataSupport} instance with the
+   * specified type using the supplied arrays of field names and
+   * values.  Neither the type, the two arrays or any elements of the
+   * arrays may be <code>null</code>.  The {@link java.lang.String}s
+   * within the <code>names</code> array must be non-empty.  The
+   * arrays must match in size and order, as each element of the
+   * <code>names</code> array is matched against the corresponding
+   * value in the <code>values</code> array.  Internally, the two are
+   * stored in a map, lexographically ordered using the field names.
+   * The data given should also conform to the description of the
+   * instance given by the {@link CompositeType} instance supplied.
+   *
+   * @param type the composite type of this composite data structure.
+   * @param names the field names.
+   * @param values the corresponding values of the fields.
+   * @throws IllegalArgumentException if the type, the arrays or any of the keys
+   *                                  or values in the arrays are <code>null</code>,
+   *                                  or if any key from <code>names</code> is
+   *                                  an empty string.  This also occurs if the
+   *                                  arrays differ in length.
+   * @throws OpenDataException if a mismatch occurs between the arrays and the
+   *                           field name/type specification given by the
+   *                           {@link CompositeType} instance.  This may be
+   *                           due to a differing number of field names, a
+   *                           mismatch between names or an incorrectly typed
+   *                           value.
+   */
+  public CompositeDataSupport(CompositeType type, String[] names, Object[] values)
+    throws OpenDataException
+  {
+    if (type == null)
+      throw new IllegalArgumentException("The given composite type is null.");
+    compositeType = type;
+    if (names == null)
+      throw new IllegalArgumentException("The names array is null.");
+    if (values == null)
+      throw new IllegalArgumentException("The values array is null.");
+    if (names.length != values.length)
+      throw new IllegalArgumentException("The sizes of the arrays differ.");
+    Set<String> typeKeys = type.keySet();
+    if (typeKeys.size() != names.length)
+      throw new OpenDataException("The number of field names does not match " +
+                                  "the type description.");
+    contents = new TreeMap<String, Object>();
+    for (int a = 0; a < names.length; ++a)
+      {
+        if (names[a] == null)
+          throw new IllegalArgumentException("Element " + a + " of the names " +
+                                             "array is null.");
+        if (names[a].length() == 0)
+          throw new IllegalArgumentException("Element " + a + " of the names " +
+                                             "array is an empty string.");
+        if (values[a] == null)
+          throw new IllegalArgumentException("Element " + a + " of the values " +
+                                             "array is null.");
+        if (!(typeKeys.contains(names[a])))
+          throw new OpenDataException("The name, " + names[a] + ", is not a " +
+                                      "field in the given type description.");
+        if (!(type.getType(names[a]).isValue(values[a])))
+          throw new OpenDataException("The value, " + values[a] + ", is not a " +
+                                      "valid value for the " + names[a] + " field.");
+        contents.put(names[a], values[a]);
+      }
+  }
+
+  /**
+   * Returns true if this {@link CompositeData} instance contains
+   * the specified key.  This method always returns false for
+   * an input key equal to <code>null</code> or the empty string.
+   *
+   * @param key the key to find in the structure.
+   * @return true if the key exists.
+   */
+  public boolean containsKey(String key)
+  {
+    if (key == null || key.length() == 0)
+      return false;
+    else
+      return contents.containsKey(key);
+  }
+
+  /**
+   * Returns true if this {@link CompositeData} instance has
+   * a value equal to that supplied.
+   *
+   * @param value the value to look for.
+   * @return true if the value exists.
+   */
+  public boolean containsValue(Object value)
+  {
+    return contents.containsValue(value);
+  }
+
+
+  /**
+   * Compares the specified object with this object for equality.
+   * The object is judged equivalent if it is non-null, and also
+   * an instance of {@link CompositeData} with the same name-value
+   * mappings and types.  The two compared instances may be
+   * equivalent even if they represent different implementations of
+   * {@link CompositeData}.
+   *
+   * @param obj the object to compare for equality.
+   * @return true if <code>obj</code> is equal to <code>this</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof CompositeData))
+      return false;
+    CompositeData data = (CompositeData) obj;
+    if (!(data.getCompositeType().equals(compositeType)))
+      return false;
+    for (String key : contents.keySet())
+      {
+        if (!(data.containsKey(key)))
+          return false;
+        if (!(data.get(key).equals(contents.get(key))))
+          return false;
+      }
+    return true;
+  }
+
+  /**
+   * Retrieves the value for the specified key.
+   *
+   * @param key the key whose value should be returned.
+   * @return the matching value.
+   * @throws IllegalArgumentException if the key is <code>null</code>
+   *                                  or the empty string.
+   * @throws InvalidKeyException if the key does not exist.
+   */
+  public Object get(String key)
+  {
+    if (key == null)
+      throw new IllegalArgumentException("The supplied key is null.");
+    if (key.length() == 0)
+      throw new IllegalArgumentException("The supplied key is the empty string.");
+    if (!(contents.containsKey(key)))
+      throw new InvalidKeyException("The supplied key does not exist.");
+    return contents.get(key);
+  }
+
+  /**
+   * Returns the appropriate value for each key in the given array,
+   * using the same ordering.
+   *
+   * @param keys the keys whose values should be returned.
+   * @return the matching values.
+   * @throws IllegalArgumentException if one of the keys is
+   *                                  <code>null</code> or the
+   *                                  empty string.
+   * @throws InvalidKeyException if one of the keys does not exist.
+   */
+  public Object[] getAll(String[] keys)
+  {
+    Object[] values = new Object[keys.length];
+    for (int a = 0; a < keys.length; ++a)
+      values[a] = get(keys[a]);
+    return values;
+  }
+
+
+  /**
+   * Returns the composite type which corresponds to this instance
+   * of {@link CompositeData}.
+   *
+   * @return the composite type for this instance.
+   */
+  public CompositeType getCompositeType()
+  {
+    return compositeType;
+  }
+
+  /**
+   * Returns the hash code of this instance.  The hash code is
+   * computed as the sum of the hash codes of all the values plus
+   * the hash code of the composite type.  As equality comparisons
+   * take place using this same information, this should ensure that
+   * the property, <code>e1.equals(e2)</code> implies
+   * <code>e1.hashCode() == e2.hashCode(), holds for any pair
+   * of instances, <code>e1</code> and <code>e2</code>. However,
+   * this relies on the other instance implementing the
+   * <code>hashCode</code> method correctly, if it is not an
+   * instance of {@link CompositeDataSupport}.
+   *
+   * @return the hash code of this {@link CompositeData}.
+   * @see Object#equals(Object)
+   */
+  public int hashCode()
+  {
+    int code = compositeType.hashCode();
+    for (Object o : contents.values())
+      code += o.hashCode();
+    return code;
+  }
+
+
+  /**
+   * Returns a textual representation of this instance.  The
+   * exact format is left up to the implementation, but it
+   * should contain the name of the implementing class,
+   * the name of the type and a mapping of the form
+   * <code>key=value</code> for each pair of key and value.
+   *
+   * @return a {@link java.lang.String} representation of the
+   *         object.
+   */
+  public String toString()
+  {
+    return getClass().getName() +
+      "[compositeType=" + compositeType +
+      ",contents=" + contents +
+      "]";
+  }
+
+  /**
+   * Returns a read-only collection of the values associated with
+   * this instance.  The values are sorted using the lexicographic
+   * ordering of the corresponding keys.
+   *
+   * @return the values of this instance.
+   */
+  public Collection<?> values()
+  {
+    return Collections.unmodifiableCollection(contents.values());
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/CompositeType.java b/libjava/classpath/javax/management/openmbean/CompositeType.java
new file mode 100644
index 000000000..e36fed151
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/CompositeType.java
@@ -0,0 +1,320 @@
+/* CompositeType.java -- Type descriptor for CompositeData instances.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/**
+ * The open type descriptor for instances of the
+ * {@link CompositeData} class.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class CompositeType
+  extends OpenType<CompositeData>
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -5366242454346948798L;
+
+  /**
+   * A map of item names to their descriptions.
+   */
+  private TreeMap<String,String> nameToDescription;
+
+  /**
+   * A map of item names to their types.
+   */
+  private TreeMap<String,OpenType<?>> nameToType;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * <p>
+   * Constructs a new {@link CompositeType} instance for the given
+   * type name with the specified field names, descriptions and types.
+   * All parameters, and the elements of the array parameters, must be
+   * non-null and {@link java.lang.String} values must be something other
+   * than the empty string.  The arrays must be non-empty, and be of
+   * equal size.
+   * </p>
+   * <p>
+   * The result of <code>CompositeData.class.getName()</code> is adopted
+   * as the class name (see {@link OpenType}) and changes to the array
+   * elements following construction of the {@link CompositeType} instance
+   * will <strong>not</strong> affect the values used by the instance.
+   * The field names are sorted in to ascending alphanumeric order internally,
+   * and so ordering can not be used to differentiate between two instances.
+   * </p>
+   *
+   * @param name the name of this composite type.
+   * @param desc a description of this composite type.
+   * @param names the names of each field within the composite type.
+   * @param descs the descriptions of each field within the composite type.
+   * @param types the types of each field within the composite type.
+   * @throws IllegalArgumentException if any validity constraint listed above
+   *                                  is broken.
+   * @throws OpenDataException if duplicate item names are provided.  Item names
+   *                           are case-sensitive, but whitespace is removed
+   *                           before comparison.
+   */
+  public CompositeType(String name, String desc, String[] names,
+                       String[] descs, OpenType<?>[] types)
+    throws OpenDataException
+  {
+    super(CompositeData.class.getName(), name, desc);
+    if (names.length == 0
+        || names.length != descs.length
+        || names.length != types.length)
+      throw new IllegalArgumentException("Arrays must be non-empty " +
+                                         "and of equal size.");
+    nameToDescription = new TreeMap<String,String>();
+    for (int a = 0; a < names.length; ++a)
+      {
+        if (names[a] == null)
+          throw new IllegalArgumentException("Name " + a + " is null.");
+        if (descs[a] == null)
+          throw new IllegalArgumentException("Description " + a +
+                                             " is null.");
+        String fieldName = names[a].trim();
+        if (fieldName.length() == 0)
+          throw new IllegalArgumentException("Name " + a + " is " +
+                                             "the empty string.");
+        if (descs[a].length() == 0)
+          throw new IllegalArgumentException("Description " + a + " is " +
+                                             "the empty string.");
+        if (nameToDescription.containsKey(fieldName))
+          throw new OpenDataException(fieldName + " appears more " +
+                                      "than once.");
+        nameToDescription.put(fieldName, descs[a]);
+      }
+    nameToType = new TreeMap<String,OpenType<?>>();
+    for (int a = 0; a < names.length; ++a)
+      nameToType.put(names[a].trim(), types[a]);
+  }
+
+  /**
+   * Returns true if this composite data type has a field
+   * with the given name.
+   *
+   * @param name the name of the field to check for.
+   * @return true if a field of that name exists.
+   */
+  public boolean containsKey(String name)
+  {
+    return nameToDescription.containsKey(name);
+  }
+
+  /**
+   * <p>
+   * Compares this composite data type with another object
+   * for equality.  The objects are judged to be equal if:
+   * </p>
+   * <ul>
+   * <li><code>obj</code> is not null.</li>
+   * <li><code>obj</code> is an instance of
+   * {@link CompositeType}.</li>
+   * <li>The type names are equal.</li>
+   * <li>The fields and their types match.</li>
+   * </ul>
+   *
+   * @param obj the object to compare with.
+   * @return true if the conditions above hold.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof CompositeType))
+      return false;
+    CompositeType ctype = (CompositeType) obj;
+    if (!(ctype.getTypeName().equals(getTypeName())))
+      return false;
+    Set<String> keys = keySet();
+    if (!(ctype.keySet().equals(keys)))
+      return false;
+    for (String key : keys)
+    {
+      if (!(ctype.getType(key).equals(getType(key))))
+        return false;
+    }
+    return true;
+  }
+
+  /**
+   * Returns the description for the given field name,
+   * or <code>null</code> if the field name does not
+   * exist within this composite data type.
+   *
+   * @param name the name of the field whose description
+   *             should be returned.
+   * @return the description, or <code>null</code> if the
+   *         field doesn't exist.
+   */
+  public String getDescription(String name)
+  {
+    return nameToDescription.get(name);
+  }
+
+  /**
+   * Returns the type for the given field name,
+   * or <code>null</code> if the field name does not
+   * exist within this composite data type.
+   *
+   * @param name the name of the field whose type
+   *             should be returned.
+   * @return the type, or <code>null</code> if the
+   *         field doesn't exist.
+   */
+  public OpenType<?> getType(String name)
+  {
+    return nameToType.get(name);
+  }
+
+  /**
+   * <p>
+   * Returns the hash code of the composite data type.
+   * This is computed as the sum of the hash codes of
+   * each field name and its type, together with the hash
+   * code of the type name.  These are the same elements
+   * of the type that are compared as part of the
+   * {@link #equals(java.lang.Object)} method, thus ensuring
+   * that the hashcode is compatible with the equality
+   * test.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the hash code
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hash code of this instance.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      {
+        int elementTotal = 0;
+        for (Map.Entry<String,OpenType<?>> entry : nameToType.entrySet())
+          {
+            elementTotal += (entry.getKey().hashCode() +
+                             entry.getValue().hashCode());
+          }
+        hashCode = Integer.valueOf(elementTotal
+                                   + getTypeName().hashCode());
+      }
+    return hashCode.intValue();
+  }
+
+  /**
+   * Returns true if the specified object is a member of this
+   * composite type.  The object is judged to be so if it is
+   * an instance of {@link CompositeData} with an equivalent
+   * type, according to the definition of
+   * {@link #equals(java.lang.Object)} for {@link CompositeType}.
+   *
+   * @param obj the object to test for membership.
+   * @return true if the object is a member of this type.
+   */
+  public boolean isValue(Object obj)
+  {
+    if (obj instanceof CompositeData)
+      {
+        CompositeData data = (CompositeData) obj;
+        return equals(data.getCompositeType());
+      }
+    return false;
+  }
+
+  /**
+   * Returns an unmodifiable {@link java.util.Set}-based
+   * view of the field names that form part of this
+   * {@link CompositeType} instance.  The names are stored
+   * in ascending alphanumeric order.
+   *
+   * @return a unmodifiable set containing the field
+   *         name {@link java.lang.String}s.
+   */
+  public Set<String> keySet()
+  {
+    return Collections.unmodifiableSet(nameToDescription.keySet());
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.CompositeType</code>)
+   * and each element of the instance which is relevant to
+   * the definition of {@link equals(java.lang.Object)} and
+   * {@link hashCode()} (i.e. the type name, and the name
+   * and type of each field).
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getTypeName()
+        + ", fields=" + nameToType
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/InvalidKeyException.java b/libjava/classpath/javax/management/openmbean/InvalidKeyException.java
new file mode 100644
index 000000000..e9458ba91
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/InvalidKeyException.java
@@ -0,0 +1,76 @@
+/* InvalidKeyException.java -- Thrown by an invalid composite/tabular key.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+/**
+ * Thrown when an invalid key (a field name or row index) is
+ * passed to a method of the {@link CompositeData} or
+ * {@link TabularData} classes.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class InvalidKeyException
+  extends IllegalArgumentException
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 4224269443946322062L;
+
+  /**
+   * Constructs a new <code>InvalidKeyException</code>.
+   */
+  public InvalidKeyException()
+  {
+    super();
+  }
+
+  /**
+   * Constructs a new <code>InvalidKeyException</code>
+   * with the specified message.
+   *
+   * @param message the error message to give to the user.
+   */
+  public InvalidKeyException(String message)
+  {
+    super(message);
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/InvalidOpenTypeException.java b/libjava/classpath/javax/management/openmbean/InvalidOpenTypeException.java
new file mode 100644
index 000000000..b4f49ba13
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/InvalidOpenTypeException.java
@@ -0,0 +1,75 @@
+/* InvalidOpenTypeException.java -- Thrown by an invalid open type.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+/**
+ * Thrown when a open data value has an erroneous open
+ * type.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class InvalidOpenTypeException
+  extends IllegalArgumentException
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -2837312755412327534L;
+
+  /**
+   * Constructs a new <code>InvalidOpenTypeException</code>.
+   */
+  public InvalidOpenTypeException()
+  {
+    super();
+  }
+
+  /**
+   * Constructs a new <code>InvalidOpenTypeException</code>
+   * with the specified message.
+   *
+   * @param message the error message to give to the user.
+   */
+  public InvalidOpenTypeException(String message)
+  {
+    super(message);
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/KeyAlreadyExistsException.java b/libjava/classpath/javax/management/openmbean/KeyAlreadyExistsException.java
new file mode 100644
index 000000000..69b22c433
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/KeyAlreadyExistsException.java
@@ -0,0 +1,76 @@
+/* KeyAlreadyExistsException.java -- Thrown when a key clashes with another.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+/**
+ * Thrown when a key (a field name or row index) is passed to a method
+ * of the {@link CompositeData} or {@link TabularData} classes and it
+ * is found to already be in use.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class KeyAlreadyExistsException
+  extends IllegalArgumentException
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 1845183636745282866L;
+
+  /**
+   * Constructs a new <code>KeyAlreadyExistsException</code>.
+   */
+  public KeyAlreadyExistsException()
+  {
+    super();
+  }
+
+  /**
+   * Constructs a new <code>KeyAlreadyExistsException</code>
+   * with the specified message.
+   *
+   * @param message the error message to give to the user.
+   */
+  public KeyAlreadyExistsException(String message)
+  {
+    super(message);
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenDataException.java b/libjava/classpath/javax/management/openmbean/OpenDataException.java
new file mode 100644
index 000000000..5e2a0b746
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenDataException.java
@@ -0,0 +1,78 @@
+/* OpenDataException.java -- Thrown by invalid open bean data.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import javax.management.JMException;
+
+/**
+ * Thrown when an instance of one of the open types, open
+ * data objects or open metadata information objects could
+ * not be created due to invalid construction parameters.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class OpenDataException
+  extends JMException
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 8346311255433349870L;
+
+  /**
+   * Constructs a new <code>OpenDataException</code>.
+   */
+  public OpenDataException()
+  {
+    super();
+  }
+
+  /**
+   * Constructs a new <code>OpenDataException</code>
+   * with the specified message.
+   *
+   * @param message the error message to give to the user.
+   */
+  public OpenDataException(String message)
+  {
+    super(message);
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanAttributeInfo.java b/libjava/classpath/javax/management/openmbean/OpenMBeanAttributeInfo.java
new file mode 100644
index 000000000..d52130600
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanAttributeInfo.java
@@ -0,0 +1,120 @@
+/* OpenMBeanAttributeInfo.java -- Open typed info about an attribute.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+/**
+ * Describes an attribute associated with an open management bean.
+ * This interface includes those methods specified by {@link
+ * javax.management.MBeanAttributeInfo}, so implementations should
+ * extend this class.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface OpenMBeanAttributeInfo
+  extends OpenMBeanParameterInfo
+{
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanAttributeInfo}
+   * with an equal name and open type, the same default, minimum,
+   * maximum and legal values and the same access properties
+   * ({@link #isIs()}, {@link #isReadable()}, {@link #isWritable()}).
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         <code>openType.equals(object.getOpenType())</code>,
+   *         <code>defaultValue.equals(object.getDefaultValue())</code>,
+   *         <code>minValue.equals(object.getMinValue())</code>,
+   *         <code>maxValue.equals(object.getMaxValue())</code>,
+   *         <code>legalValues.equals(object.getLegalValues())</code>,
+   *         <code>is == object.isIs()</code>,
+   *         <code>isRead == object.isReadable()</code>,
+   *         and <code>isWrite == object.isWritable()</code>.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Returns the hashcode of the attribute information as the sum of
+   * the hashcodes of the name, open type, default value, maximum
+   * value, minimum value, the set of legal values and the access
+   * properties.
+   *
+   * @return the hashcode of the attribute information.
+   */
+  int hashCode();
+
+  /**
+   * Returns true if the accessor method of this attribute
+   * is of the form <code>isXXX</code>.
+   *
+   * @return true if the accessor takes the form <code>isXXX</code>.
+   */
+  boolean isIs();
+
+  /**
+   * Returns true if value of this attribute can be read.
+   *
+   * @return true if the value of the attribute can be read.
+   */
+  boolean isReadable();
+
+  /**
+   * Returns true if the value of this attribute can be changed.
+   *
+   * @return true if the value of the attribute can be changed.
+   */
+  boolean isWritable();
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanAttributeInfo</code>)
+   * along with the name, open type, default, minimum, maximum
+   * and legal values of the parameter and the access permissions
+   * ({@link #isIs()}, {@link #isReadable()}, {@link #isWritable()}).
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  String toString();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanAttributeInfoSupport.java b/libjava/classpath/javax/management/openmbean/OpenMBeanAttributeInfoSupport.java
new file mode 100644
index 000000000..098f72e71
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanAttributeInfoSupport.java
@@ -0,0 +1,547 @@
+/* OpenMBeanAttributeInfoSupport.java -- Open typed info about an attribute.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.management.MBeanAttributeInfo;
+
+/**
+ * Describes an attribute of an open management bean.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class OpenMBeanAttributeInfoSupport
+  extends MBeanAttributeInfo
+  implements OpenMBeanAttributeInfo
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -4867215622149721849L;
+
+  /**
+   * The open type of the attribute.
+   */
+  private OpenType<?> openType;
+
+  /**
+   * The default value of the attribute (may be <code>null</code>).
+   */
+  private Object defaultValue;
+
+  /**
+   * The possible legal values of the attribute (may be <code>null</code>).
+   */
+  private Set<?> legalValues;
+
+  /**
+   * The minimum value of the attribute (may be <code>null</code>).
+   */
+  private Comparable<?> minValue;
+
+  /**
+   * The maximum value of the attribute (may be <code>null</code>).
+   */
+  private Comparable<?> maxValue;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * Constructs a new {@link OpenMBeanAttributeInfo} using the
+   * specified name, description, open type and access properties.
+   * The name, description and open type may not be <code>null</code>
+   * and the name and description may not be equal to the empty
+   * string.
+   *
+   * @param name the name of the attribute.
+   * @param desc a description of the attribute.
+   * @param type the open type of the attribute.
+   * @param isReadable true if the attribute's value can be read.
+   * @param isWritable true if the attribute's value can be changed.
+   * @param isIs true if the attribute uses an accessor of the form isXXX.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   */
+  public OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<?> type,
+                                       boolean isReadable, boolean isWritable,
+                                       boolean isIs)
+  {
+    super(name, type == null ? null : type.getClassName(), desc, isReadable,
+          isWritable, isIs);
+    if (name == null)
+      throw new IllegalArgumentException("The name may not be null.");
+    if (desc == null)
+      throw new IllegalArgumentException("The description may not be null.");
+    if (type == null)
+      throw new IllegalArgumentException("The type may not be null.");
+    if (name.length() == 0)
+      throw new IllegalArgumentException("The name may not be the empty string.");
+    if (desc.length() == 0)
+      throw new IllegalArgumentException("The description may not be the " +
+                                         "empty string.");
+  }
+
+  /**
+   * Constructs a new {@link OpenMBeanAttributeInfo} using the
+   * specified name, description, open type and default value.  The
+   * name, description and open type cannot be <code>null</code> and
+   * the name and description may not be equal to the empty string.
+   * The default value may be <code>null</code>.  If non-null, it must
+   * be a valid value of the given open type.  Default values are not
+   * applicable to the open types, {@link ArrayType} and {@link
+   * TabularType}.
+   *
+   * @param name the name of the attribute.
+   * @param desc a description of the attribute.
+   * @param type the open type of the attribute.
+   * @param isReadable true if the attribute's value can be read.
+   * @param isWritable true if the attribute's value can be changed.
+   * @param isIs true if the attribute uses an accessor of the form isXXX.
+   * @param defaultValue the default value of the attribute.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   * @throws OpenDataException if <code>defaultValue<code> is non-null
+   *                           and is either not a value of the given
+   *                           open type or the open type is an instance
+   *                           of {@link ArrayType} or {@link TabularType}.
+   */
+  public <T> OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<T> type,
+                                           boolean isReadable, boolean isWritable,
+                                           boolean isIs, T defaultValue)
+    throws OpenDataException
+  {
+    this(name, desc, type, isReadable, isWritable, isIs, defaultValue, null);
+  }
+
+  /**
+   * <p>
+   * Constructs a new {@link OpenMBeanAttributeInfo} using the
+   * specified name, description, open type, access properties,
+   * default, maximum and minimum values.  The name, description
+   * and open type cannot be <code>null</code> and the name and
+   * description may not be equal to the empty string.  The
+   * default, maximum and minimum values may be <code>null</code>.
+   * The following conditions apply when the attributes mentioned
+   * are non-null:
+   * </p>
+   * <ul>
+   * <li>The values must be valid values for the given open type.</li>
+   * <li>Default values are not applicable to the open types, {@link
+   * ArrayType} and {@link TabularType}.</li>
+   * <li>The minimum value must be smaller than or equal to the maximum value
+   * (literally, <code>minValue.compareTo(maxValue) <= 0</code>.</li>
+   * <li>The minimum value must be smaller than or equal to the default value
+   * (literally, <code>minValue.compareTo(defaultValue) <= 0</code>.</li>
+   * <li>The default value must be smaller than or equal to the maximum value
+   * (literally, <code>defaultValue.compareTo(maxValue) <= 0</code>.</li>
+   * </ul>
+   *
+   * @param name the name of the attribute.
+   * @param desc a description of the attribute.
+   * @param type the open type of the attribute.
+   * @param isReadable true if the attribute's value can be read.
+   * @param isWritable true if the attribute's value can be changed.
+   * @param isIs true if the attribute uses an accessor of the form isXXX.
+   * @param defaultValue the default value of the attribute, or <code>null</code>.
+   * @param minimumValue the minimum value of the attribute, or <code>null</code>.
+   * @param maximumValue the maximum value of the attribute, or <code>null</code>.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   * @throws OpenDataException if any condition in the list above is broken.
+   */
+  @SuppressWarnings("unchecked")
+  public <T> OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<T> type,
+                                           boolean isReadable, boolean isWritable,
+                                           boolean isIs, T defaultValue,
+                                           Comparable<T> minimumValue,
+                                           Comparable<T> maximumValue)
+    throws OpenDataException
+  {
+    this(name, desc, type, isReadable, isWritable, isIs);
+    if (defaultValue != null && !(type.isValue(defaultValue)))
+      throw new OpenDataException("The default value is not a member of the " +
+                                  "open type given.");
+    if (minimumValue != null && !(type.isValue(minimumValue)))
+      throw new OpenDataException("The minimum value is not a member of the " +
+                                  "open type given.");
+    if (maximumValue != null && !(type.isValue(maximumValue)))
+      throw new OpenDataException("The maximum value is not a member of the " +
+                                  "open type given.");
+    if (defaultValue != null && (type instanceof ArrayType ||
+                                 type instanceof TabularType))
+      throw new OpenDataException("Default values are not applicable for " +
+                                  "array or tabular types.");
+    if (minimumValue != null && maximumValue != null
+        && minimumValue.compareTo((T) maximumValue) > 0)
+      throw new OpenDataException("The minimum value is greater than the " +
+                                  "maximum.");
+    if (minimumValue != null && defaultValue != null
+        && minimumValue.compareTo(defaultValue) > 0)
+      throw new OpenDataException("The minimum value is greater than the " +
+                                  "default.");
+    if (defaultValue != null && maximumValue != null
+        && maximumValue.compareTo(defaultValue) < 0)
+      throw new OpenDataException("The default value is greater than the " +
+                                  "maximum.");
+
+    openType = type;
+    this.defaultValue = defaultValue;
+    minValue = minimumValue;
+    maxValue = maximumValue;
+  }
+
+  /**
+   * <p>
+   * Constructs a new {@link OpenMBeanAttributeInfo} using the
+   * specified name, description, open type, access properties, default
+   * value and set of legal values.  The name, description and open type
+   * cannot be <code>null</code> and the name and description may not be
+   * equal to the empty string.  The default, maximum and minimum values
+   * may be <code>null</code>.  The following conditions apply when the
+   * attributes mentioned are non-null:
+   * </p>
+   * <ul>
+   * <li>The default value and each of the legal values must be a valid
+   * value for the given open type.</li>
+   * <li>Default and legal values are not applicable to the open types, {@link
+   * ArrayType} and {@link TabularType}.</li>
+   * <li>The default value is not in the set of legal values.</li>
+   * </ul>
+   * <p>
+   * The legal values are copied from the array into a unmodifiable set,
+   * so future modifications to the array have no effect.
+   * </p>
+   *
+   * @param name the name of the attribute.
+   * @param desc a description of the attribute.
+   * @param type the open type of the attribute.
+   * @param isReadable true if the attribute's value can be read.
+   * @param isWritable true if the attribute's value can be changed.
+   * @param isIs true if the attribute uses an accessor of the form isXXX.
+   * @param defaultValue the default value of the attribute, or <code>null</code>.
+   * @param legalValues the legal values of the attribute.  May be
+   *                    <code>null</code> or an empty array.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   * @throws OpenDataException if any condition in the list above is broken.
+   */
+  public <T> OpenMBeanAttributeInfoSupport(String name, String desc, OpenType<T> type,
+                                           boolean isReadable, boolean isWritable,
+                                           boolean isIs, T defaultValue,
+                                           T[] legalValues)
+    throws OpenDataException
+  {
+    this(name, desc, type, isReadable, isWritable, isIs);
+    if (defaultValue != null && !(type.isValue(defaultValue)))
+      throw new OpenDataException("The default value is not a member of the " +
+                                  "open type given.");
+    if (defaultValue != null && (type instanceof ArrayType ||
+                                 type instanceof TabularType))
+      throw new OpenDataException("Default values are not applicable for " +
+                                  "array or tabular types.");
+    if (legalValues != null && (type instanceof ArrayType ||
+                                type instanceof TabularType))
+      throw new OpenDataException("Legal values are not applicable for " +
+                                  "array or tabular types.");
+    if (legalValues != null && legalValues.length > 0)
+      {
+        Set<T> lv = new HashSet<T>(legalValues.length);
+        for (int a = 0; a < legalValues.length; ++a)
+          {
+            if (legalValues[a] != null &&
+                !(type.isValue(legalValues[a])))
+              throw new OpenDataException("The legal value, "
+                                          + legalValues[a] +
+                                          "is not a member of the " +
+                                          "open type given.");
+            lv.add(legalValues[a]);
+          }
+        if (defaultValue != null && !(lv.contains(defaultValue)))
+          throw new OpenDataException("The default value is not in the set " +
+                                      "of legal values.");
+        this.legalValues = Collections.unmodifiableSet(lv);
+      }
+    openType = type;
+    this.defaultValue = defaultValue;
+  }
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanAttributeInfo}
+   * with an equal name and open type and the same default, minimum,
+   * maximum and legal values and the same access properties.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanAttributeInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         <code>openType.equals(object.getOpenType())</code>,
+   *         <code>isRead == object.isReadable()</code>,
+   *         <code>isWrite == object.isWritable()</code>,
+   *         <code>isIs == object.isIs()</code>,
+   *         <code>defaultValue.equals(object.getDefaultValue())</code>,
+   *         <code>minValue.equals(object.getMinValue())</code>,
+   *         <code>maxValue.equals(object.getMaxValue())</code>,
+   *         and <code>legalValues.equals(object.getLegalValues())</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof OpenMBeanAttributeInfo))
+      return false;
+    OpenMBeanAttributeInfo o = (OpenMBeanAttributeInfo) obj;
+    return getName().equals(o.getName()) &&
+      openType.equals(o.getOpenType()) &&
+      isReadable() == o.isReadable() &&
+      isWritable() == o.isWritable() &&
+      isIs() == o.isIs() &&
+      (defaultValue == null ? o.getDefaultValue() == null :
+       defaultValue.equals(o.getDefaultValue())) &&
+      (minValue == null ? o.getMinValue() == null :
+       minValue.equals(o.getMinValue())) &&
+      (maxValue == null ? o.getMaxValue() == null :
+       maxValue.equals(o.getMaxValue())) &&
+      (legalValues == null ? o.getLegalValues() == null :
+       legalValues.equals(o.getLegalValues()));
+  }
+
+  /**
+   * Returns the default value of this attribute, or <code>null</code>
+   * if there is no default value.
+   *
+   * @return the default value of the attribute, or <code>null</code>
+   *         if there is no default.
+   */
+  public Object getDefaultValue()
+  {
+    return defaultValue;
+  }
+
+  /**
+   * Returns a {@link java.util.Set} enumerating the legal values
+   * of this attribute, or <code>null</code> if no such limited
+   * set exists for this attribute.
+   *
+   * @return a set of legal values, or <code>null</code> if no such
+   *         set exists.
+   */
+  public Set<?> getLegalValues()
+  {
+    return legalValues;
+  }
+
+  /**
+   * Returns the maximum value of this attribute, or <code>null</code>
+   * if there is no maximum.
+   *
+   * @return the maximum value, or <code>null</code> if none exists.
+   */
+  public Comparable<?> getMaxValue()
+  {
+    return maxValue;
+  }
+
+  /**
+   * Returns the minimum value of this attribute, or <code>null</code>
+   * if there is no minimum.
+   *
+   * @return the minimum value, or <code>null</code> if none exists.
+   */
+  public Comparable<?> getMinValue()
+  {
+    return minValue;
+  }
+
+  /**
+   * Returns the open type instance which represents the type of this
+   * attribute.
+   *
+   * @return the open type of this attribute.
+   */
+  public OpenType<?> getOpenType()
+  {
+    return openType;
+  }
+
+  /**
+   * Returns true if this attribute has a default value
+   * (i.e. the value is non-null).
+   *
+   * @return true if this attribute has a default.
+   */
+  public boolean hasDefaultValue()
+  {
+    return defaultValue != null;
+  }
+
+  /**
+   * <p>
+   * Returns the hashcode of the attribute information as the sum of
+   * the hashcodes of the name, open type, default value, maximum
+   * value, minimum value and the set of legal values.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the hash code
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hashcode of the attribute information.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode = Integer.valueOf(getName().hashCode() +
+                                 openType.hashCode() +
+                                 Boolean.valueOf(isReadable()).hashCode() +
+                                 (2 *
+                                  Boolean.valueOf(isWritable()).hashCode()) +
+                                 (4 * Boolean.valueOf(isIs()).hashCode()) +
+                                 (defaultValue == null ? 0 :
+                                  defaultValue.hashCode()) +
+                                 (minValue == null ? 0 :
+                                  minValue.hashCode()) +
+                                 (maxValue == null ? 0 :
+                                  maxValue.hashCode()) +
+                                 (legalValues == null ? 0 :
+                                  legalValues.hashCode()));
+    return hashCode.intValue();
+  }
+
+  /**
+   * Returns true if there is a set of legal values for this
+   * attribute (i.e. the value is non-null).
+   *
+   * @return true if a set of legal values exists for this
+   *         attribute.
+   */
+  public boolean hasLegalValues()
+  {
+    return legalValues != null;
+  }
+
+  /**
+   * Returns true if there is a maximum value for this attribute
+   * (i.e. the value is non-null).
+   *
+   * @return true if a maximum value exists for this attribute.
+   */
+  public boolean hasMaxValue()
+  {
+    return maxValue != null;
+  }
+
+  /**
+   * Returns true if there is a minimum value for this attribute.
+   * (i.e. the value is non-null).
+   *
+   * @return true if a minimum value exists for this attribute.
+   */
+  public boolean hasMinValue()
+  {
+    return minValue != null;
+  }
+
+  /**
+   * Returns true if the specified object is a valid value for
+   * this attribute.
+   *
+   * @param obj the object to test.
+   * @return true if <code>obj</code> is a valid value for this
+   *         attribute.
+   */
+  public boolean isValue(Object obj)
+  {
+    return openType.isValue(obj);
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanAttributeInfo</code>)
+   * along with the name, open type, access properties, default,
+   * minimum, maximum  and legal values of the attribute.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getName()
+        + ",openType=" + openType
+        + ",isReadable=" + isReadable()
+        + ",isWritable=" + isWritable()
+        + ",isIs=" + isIs()
+        + ",defaultValue=" + defaultValue
+        + ",minValue=" + minValue
+        + ",maxValue=" + maxValue
+        + ",legalValues=" + legalValues
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanConstructorInfo.java b/libjava/classpath/javax/management/openmbean/OpenMBeanConstructorInfo.java
new file mode 100644
index 000000000..5bccdb639
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanConstructorInfo.java
@@ -0,0 +1,112 @@
+/* OpenMBeanConstructorInfo.java -- Open typed info about a constructor.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import javax.management.MBeanParameterInfo;
+
+/**
+ * Describes a constructor for an open management bean.
+ * This interface includes those methods specified by {@link
+ * javax.management.MBeanConstructorInfo}, so implementations should
+ * extend this class.  The {@link #getSignature()} method should
+ * return an array containing instances of {@link OpenMBeanParameterInfo}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface OpenMBeanConstructorInfo
+{
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanConstructorInfo}
+   * with an equal name and signature.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         and <code>signature.equals(object.getSignature())</code>.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Returns a description of this constructor.
+   *
+   * @return a human-readable description.
+   */
+  String getDescription();
+
+  /**
+   * Returns the name of this constructor.
+   *
+   * @return the name of the constructor.
+   */
+  String getName();
+
+  /**
+   * Returns the constructor's signature, in the form of
+   * information on each parameter.  Each parameter is
+   * described by an instance of {@link OpenMBeanParameterInfo}.
+   *
+   * @return an array of {@link OpenMBeanParameterInfo} objects,
+   *         describing the constructor parameters.
+   */
+  MBeanParameterInfo[] getSignature();
+
+  /**
+   * Returns the hashcode of the constructor information as the sum of
+   * the hashcodes of the name and signature (calculated by
+   * <code>java.util.Arrays.asList(signature).hashCode()</code>).
+   *
+   * @return the hashcode of the constructor information.
+   */
+  int hashCode();
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanConstructorInfo</code>)
+   * along with the name and signature.
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  String toString();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanConstructorInfoSupport.java b/libjava/classpath/javax/management/openmbean/OpenMBeanConstructorInfoSupport.java
new file mode 100644
index 000000000..c187d5d13
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanConstructorInfoSupport.java
@@ -0,0 +1,174 @@
+/* OpenMBeanConstructorInfoSupport.java -- Open typed info about an constructor.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Arrays;
+
+import javax.management.MBeanConstructorInfo;
+import javax.management.MBeanParameterInfo;
+
+/**
+ * Describes a constructor for an open management bean.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class OpenMBeanConstructorInfoSupport
+  extends MBeanConstructorInfo
+  implements OpenMBeanConstructorInfo
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -4400441579007477003L;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * Constructs a @link{OpenMBeanConstructorInfo} with the specified
+   * name, description and parameter information. A <code>null</code>
+   * value for the parameter information is the same as passing in
+   * an empty array.  Neither the name nor the description may be
+   * null or equal to the empty string.  A copy of the parameter array
+   * is taken, so later changes have no effect.
+   *
+   * @param name the name of the constructor.
+   * @param desc a description of the constructor.
+   * @param sig the signature of the constructor, as a series
+   *            of {@link MBeanParameterInfo} objects, one for
+   *            each parameter.
+   * @throws IllegalArgumentException if the name or description is
+   *                                  either <code>null</code>
+   *                                  or the empty string.
+   * @throws ArrayStoreException if the members of the signature array
+   *                             are not assignable to
+   *                             {@link javax.management.MBeanParameterInfo}
+   */
+  public OpenMBeanConstructorInfoSupport(String name, String desc,
+                                         OpenMBeanParameterInfo[] sig)
+  {
+    super(name, desc, (MBeanParameterInfo[]) sig);
+    if (name == null)
+      throw new IllegalArgumentException("The name may not be null.");
+    if (desc == null)
+      throw new IllegalArgumentException("The description may not be null.");
+    if (name.length() == 0)
+      throw new IllegalArgumentException("The name may not be the empty string.");
+    if (desc.length() == 0)
+      throw new IllegalArgumentException("The description may not be the " +
+                                         "empty string.");
+  }
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanConstructorInfo}
+   * with an equal name and signature.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         and <code>signature.equals(object.getSignature())</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof OpenMBeanConstructorInfo))
+      return false;
+    OpenMBeanConstructorInfo o = (OpenMBeanConstructorInfo) obj;
+    return getName().equals(o.getName()) &&
+      getSignature().equals(o.getSignature());
+  }
+
+  /**
+   * <p>
+   * Returns the hashcode of the constructor information as the sum of
+   * the hashcodes of the name and signature (calculated by
+   * <code>java.util.Arrays.asList(signature).hashCode()</code>).
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hashcode of the constructor information.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode = Integer.valueOf(getName().hashCode() +
+                                 Arrays.asList(getSignature()).hashCode());
+    return hashCode.intValue();
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanConstructorInfo</code>)
+   * along with the name and signature.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getName()
+        + ",signature=" + Arrays.toString(getSignature())
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanInfo.java b/libjava/classpath/javax/management/openmbean/OpenMBeanInfo.java
new file mode 100644
index 000000000..98da260e7
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanInfo.java
@@ -0,0 +1,154 @@
+/* OpenMBeanInfo.java -- Open typed info about a management bean.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import javax.management.MBeanAttributeInfo;
+import javax.management.MBeanConstructorInfo;
+import javax.management.MBeanNotificationInfo;
+import javax.management.MBeanOperationInfo;
+
+/**
+ * Describes an open management bean.  Open management beans are
+ * management beans where {@link
+ * javax.management.DynamicMBean#getMBeanInfo()} returns an
+ * implementation of this interface.  This interface includes those
+ * methods specified by {@link javax.management.MBeanInfo},
+ * so implementations should extend this class.  Each method
+ * which returns an array of one of the <code>MBeanXXXInfo</code>
+ * classes should return an array containing instances
+ * of the equivalent open version (<code>OpenMBeanXXXInfo</code>).
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface OpenMBeanInfo
+{
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanInfo}
+   * with the same class name and equal instances of the info classes.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanInfo}
+   *         instance,
+   *         <code>className.equals(object.getClassName())</code>
+   *         and each info class has an equal in the other object.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Returns descriptions of each of the attributes provided by this
+   * management bean.  The elements should be implementations of the
+   * {@link OpenMBeanAttributeInfo} class.
+   *
+   * @return an array of {@link OpenMBeanAttributeInfo} objects,
+   *         representing the attributes emitted by this
+   *         management bean.
+   */
+  MBeanAttributeInfo[] getAttributes();
+
+  /**
+   * Returns the class name of the management bean.
+   *
+   * @return the bean's class name.
+   */
+  String getClassName();
+
+  /**
+   * Returns descriptions of each of the constructors provided by this
+   * management bean.  The elements should be implementations of the
+   * {@link OpenMBeanConstructorInfo} class.
+   *
+   * @return an array of {@link OpenMBeanConstructorInfo} objects,
+   *         representing the constructors emitted by this
+   *         management bean.
+   */
+  MBeanConstructorInfo[] getConstructors();
+
+  /**
+   * Returns a description of this operation.
+   *
+   * @return a human-readable description.
+   */
+  String getDescription();
+
+  /**
+   * Returns descriptions of each of the notifications provided by this
+   * management bean.  The elements should be implementations of the
+   * {@link OpenMBeanNotificationInfo} class.
+   *
+   * @return an array of {@link OpenMBeanNotificationInfo} objects,
+   *         representing the notifications emitted by this
+   *         management bean.
+   */
+  MBeanNotificationInfo[] getNotifications();
+
+  /**
+   * Returns descriptions of each of the operations provided by this
+   * management bean.  The elements should be implementations of the
+   * {@link OpenMBeanOperationInfo} class.
+   *
+   * @return an array of {@link OpenMBeanOperationInfo} objects,
+   *         representing the operations emitted by this
+   *         management bean.
+   */
+  MBeanOperationInfo[] getOperations();
+
+  /**
+   * Returns the hashcode of the bean information as the sum of the
+   * hashcodes of the class name and each array (calculated using
+   * java.util.HashSet(<code>java.util.Arrays.asList(signature)).hashCode()</code>).
+   *
+   * @return the hashcode of the bean information.
+   */
+  int hashCode();
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanInfo</code>)
+   * along with the class name and textual representations
+   * of each array.
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  String toString();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanInfoSupport.java b/libjava/classpath/javax/management/openmbean/OpenMBeanInfoSupport.java
new file mode 100644
index 000000000..c335d7512
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanInfoSupport.java
@@ -0,0 +1,191 @@
+/* OpenMBeanInfoSupport.java -- Open typed info about a bean.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+import javax.management.MBeanInfo;
+import javax.management.MBeanAttributeInfo;
+import javax.management.MBeanConstructorInfo;
+import javax.management.MBeanNotificationInfo;
+import javax.management.MBeanOperationInfo;
+
+/**
+ * Describes an open management bean.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class OpenMBeanInfoSupport
+  extends MBeanInfo
+  implements OpenMBeanInfo
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 4349395935420511492L;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * Constructs a new {@link OpenMBeanInfo} using the supplied
+   * class name and description with the given attributes,
+   * operations, constructors and notifications.  The class
+   * name does not have to actually specify a valid class that
+   * can be loaded by the MBean server or class loader; it merely
+   * has to be a syntactically correct class name.  Any of the
+   * arrays may be <code>null</code>; this will be treated as if
+   * an empty array was supplied.  A copy of the arrays is
+   * taken, so later changes have no effect.
+   *
+   * @param name the name of the class this instance describes.
+   * @param desc a description of the bean.
+   * @param attribs the attribute descriptions for the bean,
+   *                or <code>null</code>.
+   * @param cons the constructor descriptions for the bean,
+   *             or <code>null</code>.
+   * @param ops the operation descriptions for the bean,
+   *            or <code>null</code>.
+   * @param notifs the notification descriptions for the bean,
+   *               or <code>null</code>.
+   * @throws ArrayStoreException if a members of an array
+   *                             is not assignable to the equivalent
+   *                             <code>MBeanXXXInfo</code> class.
+   */
+  public OpenMBeanInfoSupport(String name, String desc,
+                              OpenMBeanAttributeInfo[] attribs,
+                              OpenMBeanConstructorInfo[] cons,
+                              OpenMBeanOperationInfo[] ops,
+                              MBeanNotificationInfo[] notifs)
+  {
+    super(name, desc, (MBeanAttributeInfo[]) attribs,
+          (MBeanConstructorInfo[]) cons,
+          (MBeanOperationInfo[]) ops,
+          notifs);
+  }
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanInfo}
+   * with the same class name and equal instances of the info classes.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanInfo}
+   *         instance,
+   *         <code>className.equals(object.getClassName())</code>
+   *         and each info class has an equal in the other object.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof OpenMBeanInfo))
+      return false;
+    OpenMBeanInfo o = (OpenMBeanInfo) obj;
+    return getClassName().equals(o.getClassName()) &&
+      getAttributes().equals(o.getAttributes()) &&
+      getConstructors().equals(o.getConstructors()) &&
+      getNotifications().equals(o.getNotifications()) &&
+      getOperations().equals(o.getOperations());
+  }
+
+  /**
+   * <p>
+   * Returns the hashcode of the bean information as the sum of the
+   * hashcodes of the class name and each array (calculated using
+   * java.util.HashSet(<code>java.util.Arrays.asList(signature)).hashCode()</code>).
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hashcode of the bean information.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode =
+        Integer.valueOf(getClassName().hashCode() +
+                        new HashSet<MBeanAttributeInfo>(Arrays.asList(getAttributes())).hashCode() +
+                        new HashSet<MBeanConstructorInfo>(Arrays.asList(getConstructors())).hashCode() +
+                        new HashSet<MBeanNotificationInfo>(Arrays.asList(getNotifications())).hashCode() +
+                        new HashSet<MBeanOperationInfo>(Arrays.asList(getOperations())).hashCode());
+    return hashCode.intValue();
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanInfo</code>)
+   * along with the class name and textual representations
+   * of each array.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[className=" + getClassName()
+        + ",attributes=" + Arrays.toString(getAttributes())
+        + ",constructors=" + Arrays.toString(getConstructors())
+        + ",notifications=" + Arrays.toString(getNotifications())
+        + ",operations=" + Arrays.toString(getOperations())
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanOperationInfo.java b/libjava/classpath/javax/management/openmbean/OpenMBeanOperationInfo.java
new file mode 100644
index 000000000..3b5bf9260
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanOperationInfo.java
@@ -0,0 +1,154 @@
+/* OpenMBeanOperationInfo.java -- Open typed info about a operation.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import javax.management.MBeanParameterInfo;
+
+/**
+ * Describes a operation for an open management bean.
+ * This interface includes those methods specified by {@link
+ * javax.management.MBeanOperationInfo}, so implementations should
+ * extend this class.  The {@link #getSignature()} method should
+ * return an array containing instances of {@link OpenMBeanParameterInfo}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface OpenMBeanOperationInfo
+{
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanOperationInfo}
+   * with an equal name, signature, open return type and impact.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         <code>signature.equals(object.getSignature())</code>,
+   *         <code>returnOpenType.equals(object.getReturnOpenType())</code>,
+   *         and <code>impact == object.getImpact()</code>.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Returns a description of this operation.
+   *
+   * @return a human-readable description.
+   */
+  String getDescription();
+
+  /**
+   * <p>
+   * Returns the impact of performing this operation.
+   * The value is equal to one of the following:
+   * </p>
+   * <ol>
+   * <li>{@link javax.management.MBeanOperationInfo#INFO}
+   * &mdash; the method just returns
+   * information (akin to an accessor).</li>
+   * <li>{@link javax.management.MBeanOperationInfo#ACTION}
+   * the method just alters the state of the bean, without
+   * returning a value (akin to a mutator).</li>
+   * <li>{@link javax.management.MBeanOperationInfo#ACTION_INFO}
+   * the method both makes state changes and returns a value.</li>
+   * <li>{@link javax.management.MBeanOperationInfo#UNKNOWN}
+   * the behaviour of the operation is unknown.</li>
+   * </ol>
+   *
+   * @return the impact of performing the operation.
+   */
+  int getImpact();
+
+  /**
+   * Returns the name of this operation.
+   *
+   * @return the name of the operation.
+   */
+  String getName();
+
+  /**
+   * Returns the open type instance which represents the type of the
+   * return value.
+   *
+   * @return the open type of the return value.
+   */
+  OpenType<?> getReturnOpenType();
+
+  /**
+   * Returns the return type of the operation, as the class
+   * name.  This should be identical to
+   * <code>getReturnOpenType.getClassName()</code>.
+   *
+   * @return the return type.
+   */
+  String getReturnType();
+
+  /**
+   * Returns the operation's signature, in the form of
+   * information on each parameter.  Each parameter is
+   * described by an instance of {@link OpenMBeanParameterInfo}.
+   *
+   * @return an array of {@link OpenMBeanParameterInfo} objects,
+   *         describing the operation parameters.
+   */
+  MBeanParameterInfo[] getSignature();
+
+  /**
+   * Returns the hashcode of the operation information as the sum of
+   * the hashcodes of the name, open return type, impact and signature
+   * (calculated by
+   * <code>java.util.Arrays.asList(signature).hashCode()</code>).
+   *
+   * @return the hashcode of the operation information.
+   */
+  int hashCode();
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanOperationInfo</code>)
+   * along with the name, signature, open return type and impact.
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  String toString();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanOperationInfoSupport.java b/libjava/classpath/javax/management/openmbean/OpenMBeanOperationInfoSupport.java
new file mode 100644
index 000000000..992df344a
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanOperationInfoSupport.java
@@ -0,0 +1,240 @@
+/* OpenMBeanOperationInfoSupport.java -- Open typed info about an operation.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Arrays;
+
+import javax.management.MBeanOperationInfo;
+import javax.management.MBeanParameterInfo;
+
+/**
+ * Describes a operation for an open management bean.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class OpenMBeanOperationInfoSupport
+  extends MBeanOperationInfo
+  implements OpenMBeanOperationInfo
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 4996859732565369366L;
+
+  /**
+   * The open type representing the return value.
+   */
+  private OpenType<?> returnOpenType;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * Constructs a @link{OpenMBeanOperationInfo} with the specified name,
+   * description, parameter information, open return type and impact. A
+   * <code>null</code> value for the parameter information is the same
+   * as passing in an empty array.  A copy of the parameter array is
+   * taken, so later changes have no effect.  The name and the
+   * description may not be equal to the empty string, and neither
+   * the name, description nor the open return type may be
+   * <code>null</code>.  The value of <code>impact</code> must be
+   * one of the four valid values
+   * ({@link javax.management.MBeanOperationInfo#INFO},
+   * {@link javax.management.MBeanOperationInfo#ACTION},
+   * {@link javax.management.MBeanOperationInfo#ACTION_INFO} and
+   * {@link javax.management.MBeanOperationInfo#UNKNOWN}).
+   *
+   *
+   * @param name the name of the constructor.
+   * @param desc a description of the attribute.
+   * @param sig the signature of the method, as a series
+   *            of {@link MBeanParameterInfo} objects, one for
+   *            each parameter.
+   * @param type the open return type of the method.
+   * @param impact the impact of performing the operation.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open return type is <code>null</code>,
+   *                                  the name or description are equal to
+   *                                  the empty string, or the impact factor
+   *                                  is not one of the values enumerated
+   *                                  above.
+   * @throws ArrayStoreException if the members of the signature array
+   *                             are not assignable to
+   *                             {@link javax.management.MBeanParameterInfo}
+   */
+  public OpenMBeanOperationInfoSupport(String name, String desc,
+                                       OpenMBeanParameterInfo[] sig,
+                                       OpenType<?> type, int impact)
+  {
+    super(name, desc, (MBeanParameterInfo[]) sig,
+          type == null ? null : type.getClassName(), impact);
+    if (name == null)
+      throw new IllegalArgumentException("The name may not be null.");
+    if (desc == null)
+      throw new IllegalArgumentException("The description may not be null.");
+    if (type == null)
+      throw new IllegalArgumentException("The type may not be null.");
+    if (name.length() == 0)
+      throw new IllegalArgumentException("The name may not be the empty string.");
+    if (desc.length() == 0)
+      throw new IllegalArgumentException("The description may not be the " +
+                                         "empty string.");
+    if (impact != ACTION && impact != INFO &&
+        impact != ACTION_INFO && impact != UNKNOWN)
+      throw new IllegalArgumentException("The impact factor is an invalid value.");
+    returnOpenType = type;
+  }
+
+  /**
+   * Compares this attribute with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanOperationInfo}
+   * with an equal name, signature, open return type and impact.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         <code>signature.equals(object.getSignature())</code>,
+   *         <code>returnOpenType.equals(object.getReturnOpenType())</code>,
+   *         and <code>impact == object.getImpact()</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof OpenMBeanOperationInfo))
+      return false;
+    OpenMBeanOperationInfo o = (OpenMBeanOperationInfo) obj;
+    return getName().equals(o.getName()) &&
+      getSignature().equals(o.getSignature()) &&
+      returnOpenType.equals(o.getReturnOpenType()) &&
+      getImpact() == o.getImpact();
+  }
+
+  /**
+   * Returns the open type instance which represents the type of the
+   * return value.
+   *
+   * @return the open type of the return value.
+   */
+  public OpenType<?> getReturnOpenType()
+  {
+    return returnOpenType;
+  }
+
+  /**
+   * <p>
+   * Returns the hashcode of the operation information as the sum of
+   * the hashcodes of the name, open return type, impact and signature
+   * (calculated by
+   * <code>java.util.Arrays.asList(signature).hashCode()</code>).
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hashcode of the operation information.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode = Integer.valueOf(getName().hashCode() +
+                                 returnOpenType.hashCode() +
+                                 Integer.valueOf(getImpact()).hashCode() +
+                                 Arrays.asList(getSignature()).hashCode());
+    return hashCode.intValue();
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanOperationInfo</code>)
+   * along with the name, signature, open return type and impact.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      {
+        String impactString;
+        switch (getImpact())
+          {
+          case INFO:
+            impactString = "INFO";
+            break;
+          case ACTION:
+            impactString = "ACTION";
+            break;
+          case ACTION_INFO:
+            impactString = "ACTION_INFO";
+            break;
+          case UNKNOWN:
+            impactString = "UNKNOWN";
+            break;
+          default:
+            impactString = "ERRONEOUS VALUE";
+          }
+        string = getClass().getName()
+          + "[name=" + getName()
+          + ",signature=" + Arrays.toString(getSignature())
+          + ",returnOpenType=" + returnOpenType
+          + ",impact=" + impactString
+          + "]";
+      }
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanParameterInfo.java b/libjava/classpath/javax/management/openmbean/OpenMBeanParameterInfo.java
new file mode 100644
index 000000000..0869a686f
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanParameterInfo.java
@@ -0,0 +1,190 @@
+/* OpenMBeanParameterInfo.java -- Open typed info about a parameter.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Set;
+
+/**
+ * Describes the parameters of a constructor or operation associated
+ * with an open management bean.  This interface includes those methods
+ * specified by {@link javax.management.MBeanParameterInfo}, so
+ * implementations should extend this class.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface OpenMBeanParameterInfo
+{
+
+  /**
+   * Compares this parameter with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanParameterInfo}
+   * with an equal name and open type and the same default, minimum,
+   * maximum and legal values.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         <code>openType.equals(object.getOpenType())</code>,
+   *         <code>defaultValue.equals(object.getDefaultValue())</code>,
+   *         <code>minValue.equals(object.getMinValue())</code>,
+   *         <code>maxValue.equals(object.getMaxValue())</code>,
+   *         and <code>legalValues.equals(object.getLegalValues())</code>.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Returns the default value of this parameter, or <code>null</code>
+   * if there is no default value.
+   *
+   * @return the default value of the parameter, or <code>null</code>
+   *         if there is no default.
+   */
+  Object getDefaultValue();
+
+  /**
+   * Returns a description of this parameter.
+   *
+   * @return a human-readable description.
+   */
+  String getDescription();
+
+  /**
+   * Returns a {@link java.util.Set} enumerating the legal values
+   * of this parameter, or <code>null</code> if no such limited
+   * set exists for this parameter.
+   *
+   * @return a set of legal values, or <code>null</code> if no such
+   *         set exists.
+   */
+  Set<?> getLegalValues();
+
+  /**
+   * Returns the maximum value of this parameter, or <code>null</code>
+   * if there is no maximum.
+   *
+   * @return the maximum value, or <code>null</code> if none exists.
+   */
+  Comparable<?> getMaxValue();
+
+  /**
+   * Returns the minimum value of this parameter, or <code>null</code>
+   * if there is no minimum.
+   *
+   * @return the minimum value, or <code>null</code> if none exists.
+   */
+  Comparable<?> getMinValue();
+
+  /**
+   * Returns the name of this parameter.
+   *
+   * @return the name of the parameter.
+   */
+  String getName();
+
+  /**
+   * Returns the open type instance which represents the type of this
+   * parameter.
+   *
+   * @return the open type of this parameter.
+   */
+  OpenType<?> getOpenType();
+
+  /**
+   * Returns true if this parameter has a default value.
+   *
+   * @return true if this parameter has a default.
+   */
+  boolean hasDefaultValue();
+
+  /**
+   * Returns the hashcode of the parameter information as the sum of
+   * the hashcodes of the name, open type, default value, maximum
+   * value, minimum value and the set of legal values.
+   *
+   * @return the hashcode of the parameter information.
+   */
+  int hashCode();
+
+  /**
+   * Returns true if there is a set of legal values for this
+   * parameter.
+   *
+   * @return true if a set of legal values exists for this
+   *         parameter.
+   */
+  boolean hasLegalValues();
+
+  /**
+   * Returns true if there is a maximum value for this parameter.
+   *
+   * @return true if a maximum value exists for this parameter.
+   */
+  boolean hasMaxValue();
+
+  /**
+   * Returns true if there is a minimum value for this parameter.
+   *
+   * @return true if a minimum value exists for this parameter.
+   */
+  boolean hasMinValue();
+
+  /**
+   * Returns true if the specified object is a valid value for
+   * this parameter.
+   *
+   * @param obj the object to test.
+   * @return true if <code>obj</code> is a valid value for this
+   *         parameter.
+   */
+  boolean isValue(Object obj);
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanParameterInfo</code>)
+   * along with the name, open type, default, minimum, maximum
+   * and legal values of the parameter.
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  String toString();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenMBeanParameterInfoSupport.java b/libjava/classpath/javax/management/openmbean/OpenMBeanParameterInfoSupport.java
new file mode 100644
index 000000000..78ad1c5a0
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenMBeanParameterInfoSupport.java
@@ -0,0 +1,512 @@
+/* OpenMBeanParameterInfoSupport.java -- Open typed info about a parameter.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.management.MBeanParameterInfo;
+
+/**
+ * Describes the parameters of a constructor or operation associated
+ * with an open management bean.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class OpenMBeanParameterInfoSupport
+  extends MBeanParameterInfo
+  implements OpenMBeanParameterInfo
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -7235016873758443122L;
+
+  /**
+   * The open type of the parameter.
+   */
+  private OpenType<?> openType;
+
+  /**
+   * The default value of the parameter (may be <code>null</code>).
+   */
+  private Object defaultValue;
+
+  /**
+   * The possible legal values of the parameter (may be <code>null</code>).
+   */
+  private Set<?> legalValues;
+
+  /**
+   * The minimum value of the parameter (may be <code>null</code>).
+   */
+  private Comparable<?> minValue;
+
+  /**
+   * The maximum value of the parameter (may be <code>null</code>).
+   */
+  private Comparable<?> maxValue;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * Constructs a new {@link OpenMBeanParameterInfo} using the specified
+   * name, description and open type.  None of these values may be
+   * <code>null</code> and the name and description may not be equal
+   * to the empty string.
+   *
+   * @param name the name of the parameter.
+   * @param desc a description of the parameter.
+   * @param type the open type of the parameter.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   */
+  public OpenMBeanParameterInfoSupport(String name, String desc, OpenType<?> type)
+  {
+    super(name, type == null ? null : type.getClassName(), desc);
+    if (name == null)
+      throw new IllegalArgumentException("The name may not be null.");
+    if (desc == null)
+      throw new IllegalArgumentException("The description may not be null.");
+    if (type == null)
+      throw new IllegalArgumentException("The type may not be null.");
+    if (name.length() == 0)
+      throw new IllegalArgumentException("The name may not be the empty string.");
+    if (desc.length() == 0)
+      throw new IllegalArgumentException("The description may not be the " +
+                                         "empty string.");
+    openType = type;
+  }
+
+  /**
+   * Constructs a new {@link OpenMBeanParameterInfo} using the
+   * specified name, description, open type and default value.  The
+   * name, description and open type cannot be <code>null</code> and
+   * the name and description may not be equal to the empty string.
+   * The default value may be <code>null</code>.  If non-null, it must
+   * be a valid value of the given open type.  Default values are not
+   * applicable to the open types, {@link ArrayType} and {@link
+   * TabularType}.
+   *
+   * @param name the name of the parameter.
+   * @param desc a description of the parameter.
+   * @param type the open type of the parameter.
+   * @param defaultValue the default value of the parameter.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   * @throws OpenDataException if <code>defaultValue<code> is non-null
+   *                           and is either not a value of the given
+   *                           open type or the open type is an instance
+   *                           of {@link ArrayType} or {@link TabularType}.
+   */
+  public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
+                                           T defaultValue)
+    throws OpenDataException
+  {
+    this(name, desc, type, defaultValue, null);
+  }
+
+  /**
+   * <p>
+   * Constructs a new {@link OpenMBeanParameterInfo} using the
+   * specified name, description, open type, default, maximum and
+   * minimum values.  The name, description and open type cannot be
+   * <code>null</code> and the name and description may not be equal
+   * to the empty string.  The default, maximum and minimum values may
+   * be <code>null</code>.  The following conditions apply when the
+   * parameters mentioned are non-null:
+   * </p>
+   * <ul>
+   * <li>The values must be valid values for the given open type.</li>
+   * <li>Default values are not applicable to the open types, {@link
+   * ArrayType} and {@link TabularType}.</li>
+   * <li>The minimum value must be smaller than or equal to the maximum value
+   * (literally, <code>minValue.compareTo(maxValue) <= 0</code>.</li>
+   * <li>The minimum value must be smaller than or equal to the default value
+   * (literally, <code>minValue.compareTo(defaultValue) <= 0</code>.</li>
+   * <li>The default value must be smaller than or equal to the maximum value
+   * (literally, <code>defaultValue.compareTo(maxValue) <= 0</code>.</li>
+   * </ul>
+   *
+   * @param name the name of the parameter.
+   * @param desc a description of the parameter.
+   * @param type the open type of the parameter.
+   * @param defaultValue the default value of the parameter, or <code>null</code>.
+   * @param minimumValue the minimum value of the parameter, or <code>null</code>.
+   * @param maximumValue the maximum value of the parameter, or <code>null</code>.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   * @throws OpenDataException if any condition in the list above is broken.
+   */
+  @SuppressWarnings("unchecked")
+  public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
+                                           T defaultValue, Comparable<T> minimumValue,
+                                           Comparable<T> maximumValue)
+    throws OpenDataException
+  {
+    this(name, desc, type);
+    if (defaultValue != null && !(type.isValue(defaultValue)))
+      throw new OpenDataException("The default value is not a member of the " +
+                                  "open type given.");
+    if (minimumValue != null && !(type.isValue(minimumValue)))
+      throw new OpenDataException("The minimum value is not a member of the " +
+                                  "open type given.");
+    if (maximumValue != null && !(type.isValue(maximumValue)))
+      throw new OpenDataException("The maximum value is not a member of the " +
+                                  "open type given.");
+    if (defaultValue != null && (type instanceof ArrayType ||
+                                 type instanceof TabularType))
+      throw new OpenDataException("Default values are not applicable for " +
+                                  "array or tabular types.");
+    if (minimumValue != null && maximumValue != null
+        && minimumValue.compareTo((T) maximumValue) > 0)
+      throw new OpenDataException("The minimum value is greater than the " +
+                                  "maximum.");
+    if (minimumValue != null && defaultValue != null
+        && minimumValue.compareTo(defaultValue) > 0)
+      throw new OpenDataException("The minimum value is greater than the " +
+                                  "default.");
+    if (defaultValue != null && maximumValue != null
+        && maximumValue.compareTo(defaultValue) < 0)
+      throw new OpenDataException("The default value is greater than the " +
+                                  "maximum.");
+
+    this.defaultValue = defaultValue;
+    minValue = minimumValue;
+    maxValue = maximumValue;
+  }
+
+  /**
+   * <p>
+   * Constructs a new {@link OpenMBeanParameterInfo} using the
+   * specified name, description, open type, default value and
+   * set of legal values.  The name, description and open type cannot be
+   * <code>null</code> and the name and description may not be equal
+   * to the empty string.  The default, maximum and minimum values may
+   * be <code>null</code>.  The following conditions apply when the
+   * parameters mentioned are non-null:
+   * </p>
+   * <ul>
+   * <li>The default value and each of the legal values must be a valid
+   * value for the given open type.</li>
+   * <li>Default and legal values are not applicable to the open types, {@link
+   * ArrayType} and {@link TabularType}.</li>
+   * <li>The default value is not in the set of legal values.</li>
+   * </ul>
+   * <p>
+   * The legal values are copied from the array into a unmodifiable set,
+   * so future modifications to the array have no effect.
+   * </p>
+   *
+   * @param name the name of the parameter.
+   * @param desc a description of the parameter.
+   * @param type the open type of the parameter.
+   * @param defaultValue the default value of the parameter, or <code>null</code>.
+   * @param legalValues the legal values of the parameter.  May be
+   *                    <code>null</code> or an empty array.
+   * @throws IllegalArgumentException if the name, description or
+   *                                  open type are <code>null</code>
+   *                                  or the name or description are
+   *                                  the empty string.
+   * @throws OpenDataException if any condition in the list above is broken.
+   */
+  public <T> OpenMBeanParameterInfoSupport(String name, String desc, OpenType<T> type,
+                                           T defaultValue, T[] legalValues)
+    throws OpenDataException
+  {
+    this(name, desc, type);
+    if (defaultValue != null && !(type.isValue(defaultValue)))
+      throw new OpenDataException("The default value is not a member of the " +
+                                  "open type given.");
+    if (defaultValue != null && (type instanceof ArrayType ||
+                                 type instanceof TabularType))
+      throw new OpenDataException("Default values are not applicable for " +
+                                  "array or tabular types.");
+    if (legalValues != null && (type instanceof ArrayType ||
+                                type instanceof TabularType))
+      throw new OpenDataException("Legal values are not applicable for " +
+                                  "array or tabular types.");
+    if (legalValues != null && legalValues.length > 0)
+      {
+        Set<T> lv = new HashSet<T>(legalValues.length);
+        for (int a = 0; a < legalValues.length; ++a)
+          {
+            if (legalValues[a] != null &&
+                !(type.isValue(legalValues[a])))
+              throw new OpenDataException("The legal value, "
+                                          + legalValues[a] +
+                                          "is not a member of the " +
+                                          "open type given.");
+            lv.add(legalValues[a]);
+          }
+        if (defaultValue != null && !(lv.contains(defaultValue)))
+          throw new OpenDataException("The default value is not in the set " +
+                                      "of legal values.");
+        this.legalValues = Collections.unmodifiableSet(lv);
+      }
+    this.defaultValue = defaultValue;
+  }
+
+  /**
+   * Compares this parameter with the supplied object.  This returns
+   * true iff the object is an instance of {@link OpenMBeanParameterInfo}
+   * with an equal name and open type and the same default, minimum,
+   * maximum and legal values.
+   *
+   * @param obj the object to compare.
+   * @return true if the object is a {@link OpenMBeanParameterInfo}
+   *         instance,
+   *         <code>name.equals(object.getName())</code>,
+   *         <code>openType.equals(object.getOpenType())</code>,
+   *         <code>defaultValue.equals(object.getDefaultValue())</code>,
+   *         <code>minValue.equals(object.getMinValue())</code>,
+   *         <code>maxValue.equals(object.getMaxValue())</code>,
+   *         and <code>legalValues.equals(object.getLegalValues())</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof OpenMBeanParameterInfo))
+      return false;
+    OpenMBeanParameterInfo o = (OpenMBeanParameterInfo) obj;
+    return getName().equals(o.getName()) &&
+      openType.equals(o.getOpenType()) &&
+      (defaultValue == null ? o.getDefaultValue() == null :
+       defaultValue.equals(o.getDefaultValue())) &&
+      (minValue == null ? o.getMinValue() == null :
+       minValue.equals(o.getMinValue())) &&
+      (maxValue == null ? o.getMaxValue() == null :
+       maxValue.equals(o.getMaxValue())) &&
+      (legalValues == null ? o.getLegalValues() == null :
+       legalValues.equals(o.getLegalValues()));
+  }
+
+  /**
+   * Returns the default value of this parameter, or <code>null</code>
+   * if there is no default value.
+   *
+   * @return the default value of the parameter, or <code>null</code>
+   *         if there is no default.
+   */
+  public Object getDefaultValue()
+  {
+    return defaultValue;
+  }
+
+  /**
+   * Returns a {@link java.util.Set} enumerating the legal values
+   * of this parameter, or <code>null</code> if no such limited
+   * set exists for this parameter.
+   *
+   * @return a set of legal values, or <code>null</code> if no such
+   *         set exists.
+   */
+  public Set<?> getLegalValues()
+  {
+    return legalValues;
+  }
+
+  /**
+   * Returns the maximum value of this parameter, or <code>null</code>
+   * if there is no maximum.
+   *
+   * @return the maximum value, or <code>null</code> if none exists.
+   */
+  public Comparable<?> getMaxValue()
+  {
+    return maxValue;
+  }
+
+  /**
+   * Returns the minimum value of this parameter, or <code>null</code>
+   * if there is no minimum.
+   *
+   * @return the minimum value, or <code>null</code> if none exists.
+   */
+  public Comparable<?> getMinValue()
+  {
+    return minValue;
+  }
+
+  /**
+   * Returns the open type instance which represents the type of this
+   * parameter.
+   *
+   * @return the open type of this parameter.
+   */
+  public OpenType<?> getOpenType()
+  {
+    return openType;
+  }
+
+  /**
+   * Returns true if this parameter has a default value
+   * (i.e. the value is non-null).
+   *
+   * @return true if this parameter has a default.
+   */
+  public boolean hasDefaultValue()
+  {
+    return defaultValue != null;
+  }
+
+  /**
+   * <p>
+   * Returns the hashcode of the parameter information as the sum of
+   * the hashcodes of the name, open type, default value, maximum
+   * value, minimum value and the set of legal values.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the hash code
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hashcode of the parameter information.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode = Integer.valueOf(getName().hashCode() +
+                                 openType.hashCode() +
+                                 (defaultValue == null ? 0 :
+                                  defaultValue.hashCode()) +
+                                 (minValue == null ? 0 :
+                                  minValue.hashCode()) +
+                                 (maxValue == null ? 0 :
+                                  maxValue.hashCode()) +
+                                 (legalValues == null ? 0 :
+                                  legalValues.hashCode()));
+    return hashCode.intValue();
+  }
+
+  /**
+   * Returns true if there is a set of legal values for this
+   * parameter (i.e. the value is non-null).
+   *
+   * @return true if a set of legal values exists for this
+   *         parameter.
+   */
+  public boolean hasLegalValues()
+  {
+    return legalValues != null;
+  }
+
+  /**
+   * Returns true if there is a maximum value for this parameter
+   * (i.e. the value is non-null).
+   *
+   * @return true if a maximum value exists for this parameter.
+   */
+  public boolean hasMaxValue()
+  {
+    return maxValue != null;
+  }
+
+  /**
+   * Returns true if there is a minimum value for this parameter.
+   * (i.e. the value is non-null).
+   *
+   * @return true if a minimum value exists for this parameter.
+   */
+  public boolean hasMinValue()
+  {
+    return minValue != null;
+  }
+
+  /**
+   * Returns true if the specified object is a valid value for
+   * this parameter.
+   *
+   * @param obj the object to test.
+   * @return true if <code>obj</code> is a valid value for this
+   *         parameter.
+   */
+  public boolean isValue(Object obj)
+  {
+    return openType.isValue(obj);
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.OpenMBeanParameterInfo</code>)
+   * along with the name, open type, default, minimum, maximum
+   * and legal values of the parameter.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getName()
+        + ",openType=" + openType
+        + ",defaultValue=" + defaultValue
+        + ",minValue=" + minValue
+        + ",maxValue=" + maxValue
+        + ",legalValues=" + legalValues
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/OpenType.java b/libjava/classpath/javax/management/openmbean/OpenType.java
new file mode 100644
index 000000000..d8abc7cf0
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/OpenType.java
@@ -0,0 +1,247 @@
+/* OpenType.java -- Superclass of all open types.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.io.Serializable;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * The superclass of all open types, which describe the
+ * applicable data values for open MBeans.  An open type
+ * is defined by its name and description, and the name
+ * of the Java class it maps to.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public abstract class OpenType<T>
+  implements Serializable
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -9195195325186646468L;
+
+  /**
+   * The name of the Java class this type represents.
+   */
+  private String className;
+
+  /**
+   * The name of this type.
+   */
+  private String typeName;
+
+  /**
+   * A description of this type.
+   */
+  private String description;
+
+  /**
+   * An array which defines the set of Java types which can be
+   * used as open types.  Note that each type is also available
+   * in array form, possibly with multiple dimensions.
+   *
+   * @deprecated Use {@link ALLOWED_CLASSNAMES_LIST} instead.
+   */
+  @Deprecated
+  public static final String[] ALLOWED_CLASSNAMES = {
+    "java.lang.Void",
+    "java.lang.Boolean",
+    "java.lang.Character",
+    "java.lang.Byte",
+    "java.lang.Short",
+    "java.lang.Integer",
+    "java.lang.Long",
+    "java.lang.Float",
+    "java.lang.Double",
+    "java.lang.String",
+    "java.math.BigDecimal",
+    "java.math.BigInteger",
+    "java.util.Date",
+    "javax.management.ObjectName",
+    CompositeData.class.getName(),
+    TabularData.class.getName()
+  };
+
+  /**
+   * A list which defines the set of Java types that may be
+   * used as open types.  Note that each type is also available
+   * in array form, possibly with multiple dimensions.
+   */
+  public static final List<String> ALLOWED_CLASSNAMES_LIST =
+    Arrays.asList(ALLOWED_CLASSNAMES);
+
+  /**
+   * Constructs a new {@link OpenType} for the specified class
+   * with the given name and description.  The name of the class
+   * must be taken from the list of {@link ALLOWED_CLASSNAMES}.
+   * Arrays are implictly included in this, and follow the usual
+   * syntax of {@link java.lang.Class#getName()} with the name
+   * preceded by n instances of '[' (where n is the number of
+   * dimensions) and an L.  The name and description can not be
+   * <code>null</code> or the empty string.
+   *
+   * @param className the name of the Java class this type
+   *                  represents.
+   * @param name the name of the type.
+   * @param desc the description of the type.
+   * @throws IllegalArgumentException if either of <code>name</code>
+   *                                  or <code>desc</code> are
+   *                                  <code>null</code> or the empty
+   *                                  string.
+   * @throws OpenDataException if the class name does not reference
+   *                           a listed class (from @{link ALLOWED_CLASSNAMES})
+   */
+  protected OpenType(String className, String name, String desc)
+    throws OpenDataException
+  {
+    if (name == null || name.equals(""))
+      throw new IllegalArgumentException("The name can not be null " +
+                                         "or the empty string.");
+    if (desc == null || desc.equals(""))
+      throw new IllegalArgumentException("The description can not " +
+                                         "be null or the empty string.");
+    Class<?> type;
+    try
+      {
+        type = Class.forName(className);
+      }
+    catch (ClassNotFoundException e)
+      {
+        throw (OpenDataException) new OpenDataException("The class name, " + className +
+                                                        ", is unavailable.").initCause(e);
+      }
+    while (type.isArray())
+      type = type.getComponentType();
+    if (!(type.isPrimitive() || ALLOWED_CLASSNAMES_LIST.contains(type.getName())))
+      throw new OpenDataException("The class name, " + className +
+                                  ", does not specify a valid open type.");
+    this.className = className;
+    typeName = name;
+    description = desc;
+  }
+
+  /**
+   * Performs an equality test on this object and the one specified.
+   *
+   * @param obj the object to test against this one.
+   * @return true if the two objects are equivalent.
+   * @see java.lang.Object#hashCode()
+   */
+  public abstract boolean equals(Object obj);
+
+  /**
+   * Returns the name of the Java class this type represents.  This must
+   * be one of the {@link ALLOWED_CLASSNAMES} or an array of one of them.
+   * The specification of arrays follows the standard set by
+   * {@link java.lang.Class#getName()} i.e. the name is the class name
+   * preceded by n instances of '[' and an 'L', where n is number of
+   * dimensions used by the array.
+   *
+   * @return the class name.
+   */
+  public String getClassName()
+  {
+    return className;
+  }
+
+  /**
+   * Returns a description of this open type.
+   *
+   * @return the description.
+   */
+  public String getDescription()
+  {
+    return description;
+  }
+
+  /**
+   * Returns the name of this open type.
+   *
+   * @return the type name.
+   */
+  public String getTypeName()
+  {
+    return typeName;
+  }
+
+  /**
+   * Returns a hash code for this open type.  The hash code
+   * should be consistent with the {@link equals()} method.
+   * Thus, it should continue to return the same value while
+   * the values used by the {@link equals()} method remain
+   * the same, and should return different hash codes for
+   * objects which are judged to be different using the
+   * {@link equals()} method.
+   *
+   * @return the hash code of this instance.
+   */
+  public abstract int hashCode();
+
+  /**
+   * Returns true if this open type represents an array type.
+   *
+   * @return true if this open type represents an array type.
+   */
+  public boolean isArray()
+  {
+    return className.startsWith("[");
+  }
+
+  /**
+   * Returns true if the specified object is a member of this
+   * type.
+   *
+   * @param obj the object to test for membership.
+   * @return true if the object is a member of this type.
+   */
+  public abstract boolean isValue(Object obj);
+
+  /**
+   * Returns a textual representation of this type.
+   *
+   * @return a {@link java.lang.String} representation of this
+   *         type.
+   */
+  public abstract String toString();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/SimpleType.java b/libjava/classpath/javax/management/openmbean/SimpleType.java
new file mode 100644
index 000000000..81b991bdf
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/SimpleType.java
@@ -0,0 +1,350 @@
+/* SimpleType.java -- Open type descriptor for the base types.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.io.InvalidObjectException;
+import java.io.ObjectStreamException;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import java.util.Date;
+
+import javax.management.ObjectName;
+
+/**
+ * The open type descriptor for data values that are members
+ * of one of the simple types (such as an integer or a string).
+ * The other open types ({@link ArrayType}, {@link CompositeType},
+ * {@link TabularType}) are constructed from one or more of these
+ * types.  The simple types are formed from a small subset of
+ * basic Java types.  As a result, the valid instances of this
+ * class are predefined, and no constructor is given for creating
+ * new instances.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public final class SimpleType<T>
+  extends OpenType<T>
+{
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.math.BigDecimal</code>.
+   */
+  public static final SimpleType<BigDecimal> BIGDECIMAL;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.math.BigInteger</code>.
+   */
+  public static final SimpleType<BigInteger> BIGINTEGER;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Boolean</code>.
+   */
+  public static final SimpleType<Boolean> BOOLEAN;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Byte</code>.
+   */
+  public static final SimpleType<Byte> BYTE;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Character</code>.
+   */
+  public static final SimpleType<Character> CHARACTER;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.util.Date</code>.
+   */
+  public static final SimpleType<Date> DATE;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Double</code>.
+   */
+  public static final SimpleType<Double> DOUBLE;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Float</code>.
+   */
+  public static final SimpleType<Float> FLOAT;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Integer</code>.
+   */
+  public static final SimpleType<Integer> INTEGER;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Long</code>.
+   */
+  public static final SimpleType<Long> LONG;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>javax.management.ObjectName</code>.
+   */
+  public static final SimpleType<ObjectName> OBJECTNAME;
+
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Short</code>.
+   */
+  public static final SimpleType<Short> SHORT;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.String</code>.
+   */
+  public static final SimpleType<String> STRING;
+
+  /**
+   * The {@link SimpleType} representation of
+   * <code>java.lang.Void</code>.
+   */
+  public static final SimpleType<Void> VOID;
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 2215577471957694503L;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * Static construction of the {@link SimpleType} instances.
+   */
+  static
+  {
+    try
+      {
+        BIGDECIMAL = new SimpleType<BigDecimal>("java.math.BigDecimal");
+        BIGINTEGER = new SimpleType<BigInteger>("java.math.BigInteger");
+        BOOLEAN = new SimpleType<Boolean>("java.lang.Boolean");
+        BYTE = new SimpleType<Byte>("java.lang.Byte");
+        CHARACTER = new SimpleType<Character>("java.lang.Character");
+        DATE = new SimpleType<Date>("java.util.Date");
+        DOUBLE = new SimpleType<Double>("java.lang.Double");
+        FLOAT = new SimpleType<Float>("java.lang.Float");
+        INTEGER = new SimpleType<Integer>("java.lang.Integer");
+        LONG = new SimpleType<Long>("java.lang.Long");
+        OBJECTNAME =
+          new SimpleType<ObjectName>("javax.management.ObjectName");
+        SHORT = new SimpleType<Short>("java.lang.Short");
+        STRING = new SimpleType<String>("java.lang.String");
+        VOID = new SimpleType<Void>("java.lang.Void");
+      }
+    catch (OpenDataException e)
+      {
+        /* In normal circumstances, this shouldn't be possible. */
+        throw new IllegalStateException("A invalid class name " +
+                                        "was passed to the SimpleType " +
+                                        "constructor.", e);
+      }
+  }
+
+  /**
+   * Constructs a new {@link SimpleType} instance for the given
+   * class name.  The class name is also used as the type name
+   * and description of the {@link OpenType} instance.
+   *
+   * @param name the name of the class this instance should
+   *             represent.
+   * @throws OpenDataException if somehow the constructor of the
+   *                           superclass is passed an invalid
+   *                           class name.
+   */
+  private SimpleType(String name)
+    throws OpenDataException
+  {
+    super(name, name, name);
+  }
+
+  /**
+   * <p>
+   * Compares this simple data type with another object
+   * for equality.  The objects are judged to be equal if:
+   * </p>
+   * <ul>
+   * <li><code>obj</code> is not null.</li>
+   * <li><code>obj</code> is an instance of
+   * {@link SimpleType}.</li>
+   * <li>The class names are equal.</li>
+   * </ul>
+   *
+   * @param obj the object to compare with.
+   * @return true if the conditions above hold.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof SimpleType))
+      return false;
+    SimpleType<?> sType = (SimpleType<?>) obj;
+    return sType.getClassName().equals(getClassName());
+  }
+
+  /**
+   * <p>
+   * Returns the hash code of the simple data type.
+   * This is simply the hash code of the class name,
+   * which is the same element of the type compared
+   * as part of the
+   * {@link #equals(java.lang.Object)} method, thus ensuring
+   * that the hashcode is compatible with the equality
+   * test.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the hash code
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hash code of this instance.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      hashCode = Integer.valueOf(getClassName().hashCode());
+    return hashCode.intValue();
+  }
+
+  /**
+   * Returns true if the specified object is a member of this
+   * simple type.  The object is judged to be so if it is
+   * non-null and its class name is the same as that returned
+   * by {@link SimpleType#getClassName()}.
+   *
+   * @param obj the object to test for membership.
+   * @return true if the object is a member of this type.
+   */
+  public boolean isValue(Object obj)
+  {
+    if (obj == null)
+      return false;
+    return obj.getClass().getName().equals(getClassName());
+  }
+
+  /**
+   * Replaces instances of this class read from an
+   * {@link java.io.ObjectInputStream} with one of the predefined
+   * values.  This ensures that each existing instance of
+   * this class is one of these unique instances.
+   *
+   * @return the replacement object.
+   * @throws ObjectStreamException if the object can not be
+   *                               resolved.
+   */
+  public Object readResolve()
+    throws ObjectStreamException
+  {
+    if (equals(BIGDECIMAL))
+      return BIGDECIMAL;
+    if (equals(BIGINTEGER))
+      return BIGINTEGER;
+    if (equals(BOOLEAN))
+      return BOOLEAN;
+    if (equals(BYTE))
+      return BYTE;
+    if (equals(CHARACTER))
+      return CHARACTER;
+    if (equals(DATE))
+      return DATE;
+    if (equals(DOUBLE))
+      return DOUBLE;
+    if (equals(FLOAT))
+      return FLOAT;
+    if (equals(INTEGER))
+      return INTEGER;
+    if (equals(LONG))
+      return LONG;
+    if (equals(OBJECTNAME))
+      return OBJECTNAME;
+    if (equals(SHORT))
+      return SHORT;
+    if (equals(STRING))
+      return STRING;
+    if (equals(VOID))
+      return VOID;
+    throw new InvalidObjectException("Invalid simple type instance " +
+                                     "deserialized.");
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.SimpleType</code>)
+   * and the name of the class the type represents.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getClassName()
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/TabularData.java b/libjava/classpath/javax/management/openmbean/TabularData.java
new file mode 100644
index 000000000..8bceae85e
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/TabularData.java
@@ -0,0 +1,258 @@
+/* TabularData.java -- Tables of composite data structures.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * Provides an interface to a specific type of composite
+ * data structure, where keys (the columns) map to the
+ * {@link CompositeData} objects that form the rows of
+ * the table.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface TabularData
+{
+
+  /**
+   * Calculates the index the specified {@link CompositeData} value
+   * would have, if it was to be added to this {@link TabularData}
+   * instance.  This method includes a check that the type of the
+   * given value is the same as the row type of this instance, but not
+   * a check for existing instances of the given value.  The value
+   * must also not be <code>null</code>.  Possible indices are
+   * returned by the {@link TabularType#getIndexNames()} method of
+   * this instance's tabular type.  The returned indices are the
+   * values of the fields in the supplied {@link CompositeData}
+   * instance that match the names given in the {@link TabularType}.
+   *
+   * @param val the {@link CompositeData} value whose index should
+   *            be calculated.
+   * @return the index the value would take on, if it were to be added.
+   * @throws NullPointerException if the value is <code>null</code>.
+   * @throws InvalidOpenTypeException if the value does not match the
+   *                                  row type of this instance.
+   */
+  Object[] calculateIndex(CompositeData val);
+
+  /**
+   * Removes all {@link CompositeData} values from the table.
+   */
+  void clear();
+
+  /**
+   * Returns true iff this instance of the {@link TabularData} class
+   * contains a {@link CompositeData} value at the specified index.
+   * In any other circumstance, including if the given key
+   * is <code>null</code> or of the incorrect type, according to
+   * the {@link TabularType} of this instance, this method returns
+   * false.
+   *
+   * @param key the key to test for.
+   * @return true if the key maps to a {@link CompositeData} value.
+   */
+  boolean containsKey(Object[] key);
+
+  /**
+   * Returns true iff this instance of the {@link TabularData} class
+   * contains the specified {@link CompositeData} value.
+   * In any other circumstance, including if the given value
+   * is <code>null</code> or of the incorrect type, according to
+   * the {@link TabularType} of this instance, this method returns
+   * false.
+   *
+   * @param val the value to test for.
+   * @return true if the value exists.
+   */
+  boolean containsValue(CompositeData val);
+
+  /**
+   * Compares the specified object with this object for equality.
+   * The object is judged equivalent if it is non-null, and also
+   * an instance of {@link TabularData} with the same row type,
+   * and {@link CompositeData} values.  The two compared instances may
+   * be equivalent even if they represent different implementations
+   * of {@link TabularData}.
+   *
+   * @param obj the object to compare for equality.
+   * @return true if <code>obj</code> is equal to <code>this</code>.
+   */
+  boolean equals(Object obj);
+
+  /**
+   * Retrieves the {@link CompositeData} value for the specified
+   * key, or <code>null</code> if no such mapping exists.
+   *
+   * @param key the key whose value should be returned.
+   * @return the matching {@link CompositeData} value, or
+   *         <code>null</code> if one does not exist.
+   * @throws NullPointerException if the key is <code>null</code>.
+   * @throws InvalidKeyException if the key does not match
+   *                             the {@link TabularType} of this
+   *                             instance.
+   */
+  CompositeData get(Object[] key);
+
+  /**
+   * Returns the tabular type which corresponds to this instance
+   * of {@link TabularData}.
+   *
+   * @return the tabular type for this instance.
+   */
+  TabularType getTabularType();
+
+  /**
+   * Returns the hash code of the composite data type.  This is
+   * computed as the sum of the hash codes of each value, together
+   * with the hash code of the tabular type.  These are the same
+   * elements of the type that are compared as part of the {@link
+   * #equals(java.lang.Object)} method, thus ensuring that the
+   * hashcode is compatible with the equality test.
+   *
+   * @return the hash code of this instance.
+   */
+  int hashCode();
+
+  /**
+   * Returns true if this {@link TabularData} instance
+   * contains no {@link CompositeData} values.
+   *
+   * @return true if the instance is devoid of rows.
+   */
+  boolean isEmpty();
+
+  /**
+   * Returns a {@link java.util.Set} view of the keys or
+   * indices of this {@link TabularData} instance.
+   *
+   * @return a set containing the keys of this instance.
+   */
+  Set<?> keySet();
+
+  /**
+   * Adds the specified {@link CompositeData} value to the
+   * table.  The value must be non-null, of the same type
+   * as the row type of this instance, and must not have
+   * the same index as an existing value.  The index is
+   * calculated using the index names of the
+   * {@link TabularType} for this instance.
+   *
+   * @param val the {@link CompositeData} value to add.
+   * @throws NullPointerException if <code>val</code> is
+   *                              <code>null</code>.
+   * @throws InvalidOpenTypeException if the type of the
+   *                                  given value does not
+   *                                  match the row type.
+   * @throws KeyAlreadyExistsException if the value has the
+   *                                   same calculated index
+   *                                   as an existing value.
+   */
+  void put(CompositeData val);
+
+  /**
+   * Adds each of the specified {@link CompositeData} values
+   * to the table.  Each element of the array must meet the
+   * conditions given for the {@link #put(CompositeData)}
+   * method.  In addition, the index of each value in the
+   * array must be distinct from the index of the other
+   * values in the array, as well as from the existing values
+   * in the table.  The operation should be atomic; if one
+   * value can not be added, then none of the values should
+   * be.  If the array is <code>null</code> or empty, the
+   * method simply returns.
+   *
+   * @param vals the {@link CompositeData} values to add.
+   * @throws NullPointerException if a value from the array is
+   *                              <code>null</code>.
+   * @throws InvalidOpenTypeException if the type of a
+   *                                  given value does not
+   *                                  match the row type.
+   * @throws KeyAlreadyExistsException if a value has the
+   *                                   same calculated index
+   *                                   as an existing value or
+   *                                   of one of the other
+   *                                   specified values.
+   */
+  void putAll(CompositeData[] vals);
+
+  /**
+   * Removes the {@link CompositeData} value located at the
+   * specified index.  <code>null</code> is returned if the
+   * value does not exist.  Otherwise, the removed value is
+   * returned.
+   *
+   * @param key the key of the value to remove.
+   * @return the removed value, or <code>null</code> if
+   *         there is no value for the given key.
+   * @throws NullPointerException if the key is <code>null</code>.
+   * @throws InvalidOpenTypeException if the key does not match
+   *                                  the {@link TabularType} of this
+   *                                  instance.
+   */
+  CompositeData remove(Object[] key);
+
+  /**
+   * Returns the number of {@link CompositeData} values or rows
+   * in the table.
+   *
+   * @return the number of rows in the table.
+   */
+  int size();
+
+  /**
+   * Returns a textual representation of this instance.  The
+   * exact format is left up to the implementation, but it
+   * should contain the name of the implementing class and
+   * the tabular type.
+   *
+   * @return a {@link java.lang.String} representation of the
+   *         object.
+   */
+  String toString();
+
+  /**
+   * Returns the values associated with this instance.
+   *
+   * @return the values of this instance.
+   */
+  Collection<?> values();
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/TabularDataSupport.java b/libjava/classpath/javax/management/openmbean/TabularDataSupport.java
new file mode 100644
index 000000000..e2da1b42d
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/TabularDataSupport.java
@@ -0,0 +1,648 @@
+/* TabularDataSupport.java -- Tables of composite data structures.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.io.Serializable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Provides an implementation of the {@link TabularData}
+ * interface using a {@link java.util.HashMap}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class TabularDataSupport
+  implements TabularData, Serializable, Cloneable, Map<Object,Object>
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 5720150593236309827L;
+
+  /**
+   * Mapping of rows to column values.
+   *
+   * @serial the map of rows to column values.
+   */
+  private HashMap<Object,Object> dataMap;
+
+  /**
+   * The tabular type which represents this tabular data instance.
+   *
+   * @serial the type information for this instance.
+   */
+  private TabularType tabularType;
+
+  /**
+   * Constructs a new empty {@link TabularDataSupport} with the
+   * specified type.  The type may not be null.  This constructor
+   * simply calls the other, with the default initial capacity of
+   * <code>101</code> and default load factor of <code>0.75</code>.
+   *
+   * @param type the tabular type of this tabular data instance.
+   * @throws IllegalArgumentException if <code>type</code> is
+   *                                  <code>null</code>.
+   */
+  public TabularDataSupport(TabularType type)
+  {
+    this(type, 101, 0.75f);
+  }
+
+  /**
+   * Constructs a new empty {@link TabularDataSupport} with the
+   * specified type and the supplied initial capacity and load factor
+   * being used for the underlying {@link java.util.HashMap}.  The
+   * type may not be null and the initial capacity and load factor
+   * must be positive.
+   *
+   * @param type the tabular type of this tabular data instance.
+   * @param cap the initial capacity of the underlying map.
+   * @param lf the load factor of the underlying map.
+   * @throws IllegalArgumentException if <code>type</code> is
+   *                                  <code>null</code>, or
+   *                                  <code>cap</code> or
+   *                                  <code>lf</code> are
+   *                                  negative.
+   */
+  public TabularDataSupport(TabularType type, int cap, float lf)
+  {
+    if (type == null)
+      throw new IllegalArgumentException("The type may not be null.");
+    tabularType = type;
+    dataMap = new HashMap<Object,Object>(cap, lf);
+  }
+
+  /**
+   * Calculates the index the specified {@link CompositeData} value
+   * would have, if it was to be added to this {@link TabularData}
+   * instance.  This method includes a check that the type of the
+   * given value is the same as the row type of this instance, but not
+   * a check for existing instances of the given value.  The value
+   * must also not be <code>null</code>.  Possible indices are
+   * selected by the {@link TabularType#getIndexNames()} method of
+   * this instance's tabular type.  The returned indices are the
+   * values of the fields in the supplied {@link CompositeData}
+   * instance that match the names given in the {@link TabularType}.
+   *
+   * @param val the {@link CompositeData} value whose index should
+   *            be calculated.
+   * @return the index the value would take on, if it were to be added.
+   * @throws NullPointerException if the value is <code>null</code>.
+   * @throws InvalidOpenTypeException if the value does not match the
+   *                                  row type of this instance.
+   */
+  public Object[] calculateIndex(CompositeData val)
+  {
+    if (!(val.getCompositeType().equals(tabularType.getRowType())))
+      throw new InvalidOpenTypeException("The type of the given value " +
+                                         "does not match the row type " +
+                                         "of this instance.");
+    List<String> indexNames = tabularType.getIndexNames();
+    List<String> matchingIndicies = new ArrayList<String>(indexNames.size());
+    for (String name : indexNames)
+      matchingIndicies.add(val.get(name).toString());
+    return matchingIndicies.toArray();
+  }
+
+  /**
+   * Removes all {@link CompositeData} values from the table.
+   */
+  public void clear()
+  {
+    dataMap.clear();
+  }
+
+  /**
+   * Returns a shallow clone of the information, as obtained by the
+   * {@link Object} implementation of {@link Object#clone()}.  The map
+   * is also cloned, but it still references the same objects.
+   *
+   * @return a shallow clone of this {@link TabularDataSupport}.
+   */
+  @SuppressWarnings("unchecked")
+  public Object clone()
+  {
+    TabularDataSupport clone = null;
+    try
+      {
+        clone = (TabularDataSupport) super.clone();
+        clone.setMap((HashMap<Object,Object>) dataMap.clone());
+      }
+    catch (CloneNotSupportedException e)
+      {
+        /* This won't happen as we implement Cloneable */
+      }
+    return clone;
+  }
+
+  /**
+   * Returns true iff this instance of the {@link TabularData} class
+   * contains a {@link CompositeData} value at the specified index.
+   * The method returns <code>false</code> if the given key can
+   * not be cast to an {@link java.lang.Object} array; otherwise
+   * it returns the result of {@link #containsKey(java.lang.Object[])}.
+   *
+   *
+   * @param key the key to test for.
+   * @return true if the key maps to a {@link CompositeData} value.
+   */
+  public boolean containsKey(Object key)
+  {
+    if (key instanceof Object[])
+      return containsKey((Object[]) key);
+    else
+      return false;
+  }
+
+  /**
+   * Returns true iff this instance of the {@link TabularData} class
+   * contains a {@link CompositeData} value at the specified index.
+   * In any other circumstance, including if the given key
+   * is <code>null</code> or of the incorrect type, according to
+   * the {@link TabularType} of this instance, this method returns
+   * false.
+   *
+   * @param key the key to test for.
+   * @return true if the key maps to a {@link CompositeData} value.
+   */
+  public boolean containsKey(Object[] key)
+  {
+    if (key == null)
+      return false;
+    if (!(isKeyValid(key)))
+      return false;
+    return dataMap.containsKey(key);
+  }
+
+  /**
+   * Returns true iff this instance of the {@link TabularData} class
+   * contains the specified {@link CompositeData} value.  If the given
+   * value is not an instance of {@link CompositeData}, this method
+   * simply returns false.
+   *
+   * @param val the value to test for.
+   * @return true if the value exists.
+   */
+  public boolean containsValue(Object val)
+  {
+    if (val instanceof CompositeData)
+      return containsValue((CompositeData) val);
+    else
+      return false;
+  }
+
+  /**
+   * Returns true iff this instance of the {@link TabularData} class
+   * contains the specified {@link CompositeData} value.
+   * In any other circumstance, including if the given value
+   * is <code>null</code> or of the incorrect type, according to
+   * the {@link TabularType} of this instance, this method returns
+   * false.
+   *
+   * @param val the value to test for.
+   * @return true if the value exists.
+   */
+  public boolean containsValue(CompositeData val)
+  {
+    if (val == null)
+      return false;
+    if (!(val.getCompositeType().equals(tabularType.getRowType())))
+      return false;
+    return dataMap.containsValue(val);
+  }
+
+  /**
+   * <p>
+   * Returns a set view of the mappings in this Map.  Each element in the
+   * set is a Map.Entry.  The set is backed by the map, so that changes in
+   * one show up in the other.  Modifications made while an iterator is
+   * in progress cause undefined behavior.  If the set supports removal,
+   * these methods remove the underlying mapping from the map:
+   * <code>Iterator.remove</code>, <code>Set.remove</code>,
+   * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>.
+   * Element addition, via <code>add</code> or <code>addAll</code>, is
+   * not supported via this set.
+   * </p>
+   * <p>
+   * <strong>Note</strong>: using the
+   * {@link java.util.Map.Entry#setValue(Object) will cause corruption of
+   * the index to row mappings.
+   * </p>
+   *
+   * @return the set view of all mapping entries
+   * @see java.util.Map.Entry
+   */
+  public Set<Map.Entry<Object,Object>> entrySet()
+  {
+    return dataMap.entrySet();
+  }
+
+  /**
+   * Compares the specified object with this object for equality.
+   * The object is judged equivalent if it is non-null, and also
+   * an instance of {@link TabularData} with the same row type,
+   * and {@link CompositeData} values.  The two compared instances may
+   * be equivalent even if they represent different implementations
+   * of {@link TabularData}.
+   *
+   * @param obj the object to compare for equality.
+   * @return true if <code>obj</code> is equal to <code>this</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof TabularData))
+      return false;
+    TabularData data = (TabularData) obj;
+    return tabularType.equals(data.getTabularType()) &&
+      dataMap.values().equals(data.values());
+  }
+
+  /**
+   * Retrieves the value for the specified key by simply
+   * calling <code>get((Object[]) key)</code>.
+   *
+   * @param key the key whose value should be returned.
+   * @return the matching {@link CompositeData} value, or
+   *         <code>null</code> if one does not exist.
+   * @throws NullPointerException if the key is <code>null</code>.
+   * @throws ClassCastException if the key is not an instance
+   *                            of <code>Object[]</code>.
+   * @throws InvalidKeyException if the key does not match
+   *                             the {@link TabularType} of this
+   *                             instance.
+   */
+  public Object get(Object key)
+  {
+    return get((Object[]) key);
+  }
+
+  /**
+   * Retrieves the {@link CompositeData} value for the specified
+   * key, or <code>null</code> if no such mapping exists.
+   *
+   * @param key the key whose value should be returned.
+   * @return the matching {@link CompositeData} value, or
+   *         <code>null</code> if one does not exist.
+   * @throws NullPointerException if the key is <code>null</code>.
+   * @throws InvalidKeyException if the key does not match
+   *                             the {@link TabularType} of this
+   *                             instance.
+   */
+  public CompositeData get(Object[] key)
+  {
+    if (!(isKeyValid(key)))
+      throw new InvalidKeyException("The key does not match the " +
+                                    "tabular type of this instance.");
+    return (CompositeData) dataMap.get(key);
+  }
+
+  /**
+   * Returns the tabular type which corresponds to this instance
+   * of {@link TabularData}.
+   *
+   * @return the tabular type for this instance.
+   */
+  public TabularType getTabularType()
+  {
+    return tabularType;
+  }
+
+  /**
+   * Returns the hash code of the composite data type.  This is
+   * computed as the sum of the hash codes of each value, together
+   * with the hash code of the tabular type.  These are the same
+   * elements of the type that are compared as part of the {@link
+   * #equals(java.lang.Object)} method, thus ensuring that the
+   * hashcode is compatible with the equality test.
+   *
+   * @return the hash code of this instance.
+   */
+  public int hashCode()
+  {
+    return tabularType.hashCode() + dataMap.values().hashCode();
+  }
+
+  /**
+   * Returns true if this {@link TabularData} instance
+   * contains no {@link CompositeData} values.
+   *
+   * @return true if the instance is devoid of rows.
+   */
+  public boolean isEmpty()
+  {
+    return dataMap.isEmpty();
+  }
+
+  /**
+   * Returns true if the given key is valid for the
+   * @link{TabularType} of this instance.
+   *
+   * @return true if the key is valid.
+   * @throws NullPointerException if <code>key</code>
+   *                              is null.
+   */
+  private boolean isKeyValid(Object[] key)
+  {
+    Iterator<String> it = tabularType.getIndexNames().iterator();
+    CompositeType rowType = tabularType.getRowType();
+    for (int a = 0; it.hasNext(); ++a)
+      {
+        OpenType<?> type = rowType.getType(it.next());
+        if (!(type.isValue(key[a])))
+          return false;
+      }
+    return true;
+  }
+
+  /**
+   * Returns a set view of the keys in this Map.  The set is backed by the
+   * map, so that changes in one show up in the other.  Modifications made
+   * while an iterator is in progress cause undefined behavior.  If the set
+   * supports removal, these methods remove the underlying mapping from
+   * the map: <code>Iterator.remove</code>, <code>Set.remove</code>,
+   * <code>removeAll</code>, <code>retainAll</code>, and <code>clear</code>.
+   * Element addition, via <code>add</code> or <code>addAll</code>, is
+   * not supported via this set.
+   *
+   * @return the set view of all keys
+   */
+  public Set<Object> keySet()
+  {
+    return dataMap.keySet();
+  }
+
+  /**
+   * Adds the specified {@link CompositeData} value to the
+   * table.  The value must be non-null, of the same type
+   * as the row type of this instance, and must not have
+   * the same index as an existing value.  The index is
+   * calculated using the index names of the
+   * {@link TabularType} for this instance.
+   *
+   * @param val the {@link CompositeData} value to add.
+   * @throws NullPointerException if <code>val</code> is
+   *                              <code>null</code>.
+   * @throws InvalidOpenTypeException if the type of the
+   *                                  given value does not
+   *                                  match the row type.
+   * @throws KeyAlreadyExistsException if the value has the
+   *                                   same calculated index
+   *                                   as an existing value.
+   */
+  public void put(CompositeData val)
+  {
+    Object[] key = calculateIndex(val);
+    if (dataMap.containsKey(key))
+      throw new KeyAlreadyExistsException("A value with this index " +
+                                          "already exists.");
+    dataMap.put(key, val);
+  }
+
+  /**
+   * Adds the specified {@link CompositeData} value to the
+   * table, ignoring the supplied key, by simply calling
+   * <code>put((CompositeData) val)</code>.
+   *
+   * @param key ignored.
+   * @param val the {@link CompositeData} value to add.
+   * @return the {@link CompositeData} value.
+   * @throws NullPointerException if <code>val</code> is
+   *                              <code>null</code>.
+   * @throws InvalidOpenTypeException if the type of the
+   *                                  given value does not
+   *                                  match the row type.
+   * @throws KeyAlreadyExistsException if the value has the
+   *                                   same calculated index
+   *                                   as an existing value.
+   */
+  public Object put(Object key, Object val)
+  {
+    put((CompositeData) val);
+    return val;
+  }
+
+  /**
+   * Adds each of the specified {@link CompositeData} values
+   * to the table.  Each element of the array must meet the
+   * conditions given for the {@link #put(CompositeData)}
+   * method.  In addition, the index of each value in the
+   * array must be distinct from the index of the other
+   * values in the array, as well as from the existing values
+   * in the table.  The operation should be atomic; if one
+   * value can not be added, then none of the values should
+   * be.  If the array is <code>null</code> or empty, the
+   * method simply returns.
+   *
+   * @param vals the {@link CompositeData} values to add.
+   * @throws NullPointerException if a value from the array is
+   *                              <code>null</code>.
+   * @throws InvalidOpenTypeException if the type of a
+   *                                  given value does not
+   *                                  match the row type.
+   * @throws KeyAlreadyExistsException if a value has the
+   *                                   same calculated index
+   *                                   as an existing value or
+   *                                   of one of the other
+   *                                   specified values.
+   */
+  public void putAll(CompositeData[] vals)
+  {
+    if (vals == null || vals.length == 0)
+      return;
+    Map<Object,Object> mapToAdd = new HashMap<Object,Object>(vals.length);
+    for (int a = 0; a < vals.length; ++a)
+      {
+        Object[] key = calculateIndex(vals[a]);
+        if (dataMap.containsKey(key))
+          throw new KeyAlreadyExistsException("Element " + a + ": A " +
+                                              "value with this index " +
+                                              "already exists.");
+        mapToAdd.put(key, vals[a]);
+      }
+    dataMap.putAll(mapToAdd);
+  }
+
+  /**
+   * Converts each value from the specified map to a member of an
+   * array of {@link CompositeData} values and adds them using {@link
+   * #put(CompositeData[])}, if possible.  As in {@link
+   * #put(Object,Object)}, the keys are simply ignored.  This method
+   * is useful for adding the {@link CompositeData} values from a
+   * different {@link TabularData} instance, which uses the same
+   * {@link TabularType} but a different selection of index names, to
+   * this one.  If the map is <code>null</code> or empty, the method
+   * simply returns.
+   *
+   * @param m the map to add.  Only the values are used and must
+   *          all be instances of {@link CompositeData}.
+   * @throws NullPointerException if a value from the map is
+   *                              <code>null</code>.
+   * @throws ClassCastException if a value from the map is not
+   *                            an instance of {@link CompositeData}.
+   * @throws InvalidOpenTypeException if the type of the
+   *                                  given value does not
+   *                                  match the row type.
+   * @throws KeyAlreadyExistsException if the value has the
+   *                                   same calculated index
+   *                                   as an existing value or
+   *                                   of one of the other
+   *                                   specified values.
+   */
+  public void putAll(Map<?,?> m)
+  {
+    if (m == null || m.size() == 0)
+      return;
+    Collection<?> vals = m.values();
+    CompositeData[] data = new CompositeData[vals.size()];
+    Iterator<?> it = vals.iterator();
+    for (int a = 0; it.hasNext(); ++a)
+      {
+        data[a] = (CompositeData) it.next();
+      }
+    putAll(data);
+  }
+
+  /**
+   * Removes the value for the specified key by simply
+   * calling <code>remove((Object[]) key)</code>.
+   *
+   * @param key the key whose value should be removed.
+   * @return the removed value, or <code>null</code> if
+   *         there is no value for the given key.
+   * @throws NullPointerException if the key is <code>null</code>.
+   * @throws ClassCastException if the key is not an instance
+   *                            of <code>Object[]</code>.
+   * @throws InvalidOpenTypeException if the key does not match
+   *                                  the {@link TabularType} of this
+   *                                  instance.
+   */
+  public Object remove(Object key)
+  {
+    return remove((Object[]) key);
+  }
+
+  /**
+   * Removes the {@link CompositeData} value located at the
+   * specified index.  <code>null</code> is returned if the
+   * value does not exist.  Otherwise, the removed value is
+   * returned.
+   *
+   * @param key the key of the value to remove.
+   * @return the removed value, or <code>null</code> if
+   *         there is no value for the given key.
+   * @throws NullPointerException if the key is <code>null</code>.
+   * @throws InvalidOpenTypeException if the key does not match
+   *                                  the {@link TabularType} of this
+   *                                  instance.
+   */
+  public CompositeData remove(Object[] key)
+  {
+    if (!(isKeyValid(key)))
+      throw new InvalidKeyException("The key does not match the " +
+                                    "tabular type of this instance.");
+    return (CompositeData) dataMap.remove(key);
+  }
+
+  /**
+   * Private method to set the internal {@link java.util.Map}
+   * instance (used in cloning).
+   *
+   * @param map the new map used.
+   */
+  private void setMap(HashMap<Object,Object> map)
+  {
+    dataMap = map;
+  }
+
+  /**
+   * Returns the number of {@link CompositeData} values or rows
+   * in the table.
+   *
+   * @return the number of rows in the table.
+   */
+  public int size()
+  {
+    return dataMap.size();
+  }
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.TabularDataSupport</code>)
+   * and the result of calling <code>toString()</code> on the
+   * tabular type and underlying hash map instance.
+   *
+   * @return a {@link java.lang.String} representation of the
+   *         object.
+   */
+  public String toString()
+  {
+    return getClass().getName()
+      + "[tabularType=" + tabularType
+      + ",dataMap=" + dataMap
+      + "]";
+  }
+
+  /**
+   * Returns a collection (or bag) view of the values in this Map.  The
+   * collection is backed by the map, so that changes in one show up in
+   * the other.  Modifications made while an iterator is in progress cause
+   * undefined behavior.  If the collection supports removal, these methods
+   * remove the underlying mapping from the map: <code>Iterator.remove</code>,
+   * <code>Collection.remove</code>, <code>removeAll</code>,
+   * <code>retainAll</code>, and <code>clear</code>. Element addition, via
+   * <code>add</code> or <code>addAll</code>, is not supported via this
+   * collection.
+   *
+   * @return the collection view of all values
+   */
+  public Collection<Object> values()
+  {
+    return dataMap.values();
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/TabularType.java b/libjava/classpath/javax/management/openmbean/TabularType.java
new file mode 100644
index 000000000..5ea220701
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/TabularType.java
@@ -0,0 +1,268 @@
+/* TabularType.java -- Type descriptor for TabularData instances.
+   Copyright (C) 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package javax.management.openmbean;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * The open type descriptor for instances of the
+ * {@link TabularData} class.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class TabularType
+  extends OpenType<TabularData>
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 6554071860220659261L;
+
+  /**
+   * The composite type used by the rows of the table.
+   */
+  private CompositeType rowType;
+
+  /**
+   * The list of index names, which form the columns of the table.
+   * They are retained in the order given by the user, and is
+   * unmodifiable.
+   */
+  private List<String> indexNames;
+
+  /**
+   * The hash code of this instance.
+   */
+  private transient Integer hashCode;
+
+  /**
+   * The <code>toString()</code> result of this instance.
+   */
+  private transient String string;
+
+  /**
+   * <p>
+   * Constructs a new {@link TabularType} instance for the given
+   * type name, description, row type and index names.  All parameters
+   * (including the individual elements of the array of index names)
+   * must be non-null and those that are of type {@link java.lang.String}
+   * must be non-empty.  The array of index names must also be non-empty.
+   * </p>
+   * <p>
+   * The result of <code>TabularData.class.getName()</code> is adopted
+   * as the class name (see {@link OpenType}).  The ordering of the array
+   * elements is relevant in determining the indicies of the values in the
+   * table, and thus in the use of the
+   * {@link TabularData#get(java.lang.Object[])} and
+   * {@link TabularData#remove(java.lang.Object[])} methods of the
+   * {@link TabularData} class.
+   * </p>
+   *
+   * @param name the name of this tabular type.
+   * @param desc a description of this tabular type.
+   * @param rowType the type of the rows of the table.
+   * @param indexNames the names used to index the rows within the table.
+   * @throws IllegalArgumentException if any validity constraint listed above
+   *                                  is broken.
+   * @throws OpenDataException if an index name does not match a corresponding
+   *                           name in the given row type.
+   */
+  public TabularType(String name, String desc, CompositeType rowType,
+                     String[] indexNames)
+    throws OpenDataException
+  {
+    super(TabularData.class.getName(), name, desc);
+    if (rowType == null)
+      throw new IllegalArgumentException("A null row type was given.");
+    for (int a = 0; a < indexNames.length; ++a)
+      {
+        if (indexNames[a] == null)
+          throw new IllegalArgumentException("Name " + a +
+                                             " is null.");
+        if (indexNames[a].length() == 0)
+          throw new IllegalArgumentException("Name " + a +
+                                             " is the empty string.");
+        if (!(rowType.containsKey(indexNames[a])))
+          throw new OpenDataException("No matching key for " +
+                                      indexNames[a] + " was found in " +
+                                      "the supplied row type.");
+      }
+    this.rowType = rowType;
+    this.indexNames = Collections.unmodifiableList(Arrays.asList(indexNames));
+  }
+
+  /**
+   * <p>
+   * Compares this tabular data type with another object
+   * for equality.  The objects are judged to be equal if:
+   * </p>
+   * <ul>
+   * <li><code>obj</code> is not null.</li>
+   * <li><code>obj</code> is an instance of
+   * {@link TabularType}.</li>
+   * <li>The type names are equal.</li>
+   * <li>The row types are equal.</li>
+   * <li>The index names are equal and in the same order.</li>
+   * </ul>
+   *
+   * @param obj the object to compare with.
+   * @return true if the conditions above hold.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof TabularType))
+      return false;
+    TabularType ttype = (TabularType) obj;
+    return  (ttype.getTypeName().equals(getTypeName())
+             && (ttype.getRowType().equals(getRowType()))
+             && (ttype.getIndexNames().equals(getIndexNames())));
+  }
+
+  /**
+   * Returns an unmodifiable list containing the index names.
+   * The ordering of these names is used to determine the indicies
+   * of the {@link CompositeData} values, and is retained from that
+   * used in the call to this object's constructor.
+   *
+   * @return an unmodifiable list of the index names used by this
+   *         tabular data structure.
+   */
+  public List<String> getIndexNames()
+  {
+    return indexNames;
+  }
+
+  /**
+   * Returns the type of the rows used by this tabular data structure.
+   *
+   * @return the row type.
+   */
+  public CompositeType getRowType()
+  {
+    return rowType;
+  }
+
+  /**
+   * <p>
+   * Returns the hash code of the tabular data type.
+   * This is computed as the sum of the hash codes of the
+   * index names together with the hash code of the type
+   * name and row type.  These are the same elements
+   * of the type that are compared as part of the
+   * {@link #equals(java.lang.Object)} method, thus ensuring
+   * that the hashcode is compatible with the equality
+   * test.
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the hash code
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return the hash code of this instance.
+   */
+  public int hashCode()
+  {
+    if (hashCode == null)
+      {
+        int elementTotal = 0;
+        for (String s : indexNames)
+          elementTotal += s.hashCode();
+        hashCode = Integer.valueOf(elementTotal
+                                   + getTypeName().hashCode()
+                                   + rowType.hashCode());
+      }
+    return hashCode.intValue();
+  }
+
+  /**
+   * Returns true if the specified object is a member of this
+   * tabular type.  The object is judged to be so if it is
+   * an instance of {@link TabularData} with an equivalent
+   * type, according to the definition of
+   * {@link #equals(java.lang.Object)} for {@link TabularType}.
+   *
+   * @param obj the object to test for membership.
+   * @return true if the object is a member of this type.
+   */
+  public boolean isValue(Object obj)
+  {
+    if (obj instanceof TabularData)
+      {
+        TabularData data = (TabularData) obj;
+        return equals(data.getTabularType());
+      }
+    return false;
+  }
+
+  /**
+   * <p>
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.openmbean.TabularType</code>)
+   * and each element of the instance which is relevant to
+   * the definition of {@link equals(java.lang.Object)} and
+   * {@link hashCode()} (i.e. the type name, the row type
+   * and the index names).
+   * </p>
+   * <p>
+   * As instances of this class are immutable, the return value
+   * is computed just once for each instance and reused
+   * throughout its life.
+   * </p>
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    if (string == null)
+      string = getClass().getName()
+        + "[name=" + getTypeName()
+        + ", rowType=" + rowType
+        + ", indexNames=" + indexNames
+        + "]";
+    return string;
+  }
+
+}
diff --git a/libjava/classpath/javax/management/openmbean/package.html b/libjava/classpath/javax/management/openmbean/package.html
new file mode 100644
index 000000000..d915007d4
--- /dev/null
+++ b/libjava/classpath/javax/management/openmbean/package.html
@@ -0,0 +1,64 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<!-- package.html - describes classes in java.lang.management package.
+   Copyright (C) 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. -->
+
+<html>
+<head><title>GNU Classpath - javax.management.openmbean</title></head>
+
+<body>
+
+<p>
+Provides the data types and descriptor classes for the
+<emph>Open MBean</emph>s.  Open MBeans are provided in
+order to aid interoperability with non-Java management
+systems.  Unlike normal MBeans, which make use of any
+Java data type, Open MBeans use a restricted set of types
+which can then be mapped over remote connections, including
+to non-Java systems.
+</p>
+<p>
+Normal MBeans are described using an instance of
+{@link javax.management.MBeanInfo} with appropriate representations
+of the attributes, constructors and operators associated with
+the bean.  Open MBeans are described in the same way, but by
+using subtypes of these entities, which type the bean data using
+instances of {@link javax.management.openmbean.OpenType}.  Open
+types differ from Java types, and are explicitly specified in order
+to obtain interoperability with other systems.
+</p>
+</body>
+</html>