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

	* Merge of HEAD-->generics for 2006/09/03-2006/10/04.

11 files changed, 3815 insertions, 0 deletions

diff --git a/javax/management/BadBinaryOpValueExpException.java b/javax/management/BadBinaryOpValueExpException.java
new file mode 100644
index 000000000..5e1f5dbbe
--- /dev/null
+++ b/javax/management/BadBinaryOpValueExpException.java
@@ -0,0 +1,102 @@
+/* BadBinaryOpValueExpException.java -- Thrown by invalid query expressions.
+   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;
+
+/**
+ * Thrown when the expression passed to a method for constructing a
+ * query proves to be invalid.  This exception is only used internally
+ * by the Java management API and is not exposed to user code.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class BadBinaryOpValueExpException
+  extends Exception
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 5068475589449021227L;
+
+  /**
+   * The value expression that caused the exception.
+   */
+  private ValueExp exp;
+
+  /**
+   * Constructs a new <code>BadBinaryOpValueExpException</code>
+   * using the specified expression to represent the invalid one.
+   *
+   * @param exp the inappropriate value expression.
+   */
+  public BadBinaryOpValueExpException(ValueExp exp)
+  {
+    super();
+    this.exp = exp;
+  }
+
+  /**
+   * Returns the inappropriate value expression associated
+   * with this exception.
+   *
+   * @return the value expression.
+   */
+  public ValueExp getExp()
+  {
+    return exp;
+  }
+
+  /**
+   * Returns a textual representation of this instance.  This
+   * is constructed using the class name
+   * (<code>javax.management.BadBinaryOpValueExpException</code>)
+   * and the invalid value expression.
+   *
+   * @return a @link{java.lang.String} instance representing
+   *         the instance in textual form.
+   */
+  public String toString()
+  {
+    return getClass().getName()
+      + "[exp=" + exp 
+      + "]";
+  }
+
+}
+
diff --git a/javax/management/MBeanServer.java b/javax/management/MBeanServer.java
new file mode 100644
index 000000000..73a28e3b8
--- /dev/null
+++ b/javax/management/MBeanServer.java
@@ -0,0 +1,1199 @@
+/* MBeanServer.java -- Represents a management server.
+   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;
+
+import java.io.ObjectInputStream;
+
+import java.util.Set;
+
+import javax.management.loading.ClassLoaderRepository;
+
+/**
+ * <p>
+ * This interface represents a server for management beans,
+ * providing facilities for the creation, registration and
+ * removal of such beans.  This interface is central to the
+ * Java management architecture.  Users do not usually implement
+ * this class.  Instead, implementations of this class
+ * may be obtained using an {@link MBeanServerFactory}.
+ * </p>
+ * <p>
+ * Registering a bean with the server makes its attributes and
+ * operations accessible via the server.  Only JMX compliant
+ * beans may be registered with the server.  When a bean
+ * is registered or unregistered, an {@link MBeanServerNotification}
+ * is emitted by the server's {@link MBeanServerDelegate}.
+ * Listeners may be registered with this bean in order to
+ * obtain such notifications.  It has the {@link ObjectName}
+ * <code>JMImplementation:type=MBeanServerDelegate</code>.
+ * </p>
+ * <p>
+ * Security checks are applied on the methods of the server,
+ * as detailed below, if it is obtained using the
+ * {@link MBeanServerFactory#createMBeanServer()} or
+ * {@link MBeanServerFactory#newMBeanServer()} methods and
+ * {@link System.getSecurityManager()} returns a non-<code>null</code>
+ * value.  If a check fails, a {@link SecurityException}
+ * is thrown.  Note than the class name used in the exception
+ * is that of the bean, and thus, as a result, an
+ * {@link InstanceNotFoundException}
+ * precludes these security checks, due to the class name 
+ * that would be used in the exception being unavailable.
+ * </p>
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface MBeanServer
+  extends MBeanServerConnection
+{
+
+  /**
+   * Registers the supplied listener with the specified management
+   * bean.  Notifications emitted by the management bean are forwarded
+   * to the listener via the server, which will convert any MBean
+   * references in the source to portable {@link ObjectName}
+   * instances.  The notification is otherwise unchanged.
+   *
+   * @param name the name of the management bean with which the listener
+   *             should be registered.
+   * @param listener the listener which will handle notifications from
+   *                 the bean.
+   * @param filter the filter to apply to incoming notifications, or
+   *               <code>null</code> if no filtering should be applied.
+   * @param passback an object to be passed to the listener when a
+   *                 notification is emitted.
+   * @throws InstanceNotFoundException if the name of the management bean
+   *                                   could not be resolved.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "addNotificationListener")</code>}.
+   * @see #removeNotificationListener(ObjectName, NotificationListener)
+   * @see #removeNotificationListener(ObjectName, NotificationListener,
+   *                                  NotificationFilter, Object)
+   * @see NotificationBroadcaster#addNotificationListener(NotificationListener,
+   *                                                      NotificationFilter,
+   *                                                      Object)
+   */
+  void addNotificationListener(ObjectName name, NotificationListener listener,
+			       NotificationFilter filter, Object passback)
+    throws InstanceNotFoundException;
+
+  /**
+   * <p>
+   * Registers the supplied listener with the specified management
+   * bean.  Notifications emitted by the management bean are forwarded
+   * to the listener via the server, which will convert any MBean
+   * references in the source to portable {@link ObjectName}
+   * instances.  The notification is otherwise unchanged.  
+   * </p>
+   * <p>
+   * The listener that receives notifications will be the one that is
+   * registered with the given name at the time this method is called.
+   * Even if it later unregisters and ceases to use that name, it will
+   * still receive notifications.
+   * </p>
+   *
+   * @param name the name of the management bean with which the listener
+   *             should be registered.
+   * @param listener the name of the listener which will handle
+   *                 notifications from the bean.
+   * @param filter the filter to apply to incoming notifications, or
+   *               <code>null</code> if no filtering should be applied.
+   * @param passback an object to be passed to the listener when a
+   *                 notification is emitted.
+   * @throws InstanceNotFoundException if the name of the management bean
+   *                                   could not be resolved.
+   * @throws RuntimeOperationsException if the bean associated with the given
+   *                                    object name is not a
+   *                                    {@link NotificationListener}.  This
+   *                                    exception wraps an
+   *                                    {@link IllegalArgumentException}.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "addNotificationListener")</code>}.
+   * @see #removeNotificationListener(ObjectName, NotificationListener)
+   * @see #removeNotificationListener(ObjectName, NotificationListener,
+   *                                  NotificationFilter, Object)
+   * @see NotificationBroadcaster#addNotificationListener(NotificationListener,
+   *                                                      NotificationFilter,
+   *                                                      Object)
+   */
+  void addNotificationListener(ObjectName name, ObjectName listener,
+			       NotificationFilter filter, Object passback)
+    throws InstanceNotFoundException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the default constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * {@link javax.management.loading.ClassLoaderRepository default
+   * loader repository} of the server. 
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * <p>
+   * This method is equivalent to calling {@link 
+   * #createMBean(String, ObjectName, Object[], String[])
+   * <code>createMBean(className, name, (Object[]) null,
+   * (String[]) null)</code>} with <code>null</code> parameters
+   * and signature.
+   * </p>
+   *
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply the
+   *                           use of the <code>instantiate</code>
+   *                           and <code>registerMBean</code> methods.
+   * @see #createMBean(String, ObjectName, Object[], String[])
+   */
+  ObjectInstance createMBean(String className, ObjectName name)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the given constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * {@link javax.management.loading.ClassLoaderRepository default
+   * loader repository} of the server. 
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * 
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @param params the parameters for the bean's constructor.
+   * @param sig the signature of the constructor to use.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply the
+   *                           use of the <code>instantiate</code>
+   *                           and <code>registerMBean</code> methods.
+   */
+  ObjectInstance createMBean(String className, ObjectName name,
+			     Object[] params, String[] sig)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the default constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * given class loader.  If this argument is <code>null</code>,
+   * then the same class loader as was used to load the server
+   * is used.
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * <p>
+   * This method is equivalent to calling {@link 
+   * #createMBean(String, ObjectName, ObjectName, Object[], String)
+   * <code>createMBean(className, name, loaderName, (Object[]) null,
+   * (String) null)</code>} with <code>null</code> parameters
+   * and signature.
+   * </p>
+   *
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @param loaderName the name of the class loader.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws InstanceNotFoundException if the specified class loader is not
+   *                                   registered with the server.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply the
+   *                           use of the <code>instantiate</code>
+   *                           and <code>registerMBean</code> methods.
+   * @see #createMBean(String, ObjectName, ObjectName, Object[], String[])
+   */
+  ObjectInstance createMBean(String className, ObjectName name, 
+			     ObjectName loaderName)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException, InstanceNotFoundException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the given constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * given class loader.  If this argument is <code>null</code>,
+   * then the same class loader as was used to load the server
+   * is used. 
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * 
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @param loaderName the name of the class loader.
+   * @param params the parameters for the bean's constructor.
+   * @param sig the signature of the constructor to use.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws InstanceNotFoundException if the specified class loader is not
+   *                                   registered with the server.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply the
+   *                           use of the <code>instantiate</code>
+   *                           and <code>registerMBean</code> methods.
+   */
+  ObjectInstance createMBean(String className, ObjectName name,
+			     ObjectName loaderName, Object[] params,
+			     String[] sig)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException, InstanceNotFoundException;
+
+  /**
+   * Deserializes a byte array using the class loader of the specified
+   * management bean as its context.
+   *
+   * @param name the name of the bean whose class loader should be used.
+   * @param data the byte array to be deserialized.
+   * @return the deserialized object stream.
+   * @deprecated {@link #getClassLoaderFor(ObjectName)} should be used
+   *             to obtain the class loader of the bean, which can then
+   *             be used to perform deserialization in the user's code.
+   * @throws InstanceNotFoundException if the specified bean is not
+   *                                   registered with the server.
+   * @throws OperationsException if any I/O error is thrown by the
+   *                             deserialization process.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "getClassLoaderFor")</code>
+   */
+  ObjectInputStream deserialize(ObjectName name, byte[] data)
+    throws InstanceNotFoundException, OperationsException;
+
+  /**
+   * Deserializes a byte array using the same class loader for its context
+   * as was used to load the given class.  This class loader is obtained by
+   * loading the specified class using the {@link
+   * javax.management.loading.ClassLoaderRepository Class Loader Repository}
+   * and then using the class loader of the resulting {@link Class} instance.
+   *
+   * @param name the name of the class which should be loaded to obtain the
+   *             class loader.
+   * @param data the byte array to be deserialized.
+   * @return the deserialized object stream.
+   * @deprecated {@link #getClassLoaderRepository} should be used
+   *             to obtain the class loading repository, which can then
+   *             be used to obtain the {@link Class} instance and deserialize
+   *             the array using its class loader.
+   * @throws OperationsException if any I/O error is thrown by the
+   *                             deserialization process.
+   * @throws ReflectionException if an error occurs in obtaining the
+   *                             {@link Class} instance.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(null, null, null,
+   *                           "getClassLoaderRepository")</code>
+   */
+  ObjectInputStream deserialize(String name, byte[] data)
+    throws OperationsException, ReflectionException;
+
+  /**
+   * Deserializes a byte array using the same class loader for its context
+   * as was used to load the given class.  The name of the class loader to
+   * be used is supplied, and may be <code>null</code> if the server's
+   * class loader should be used instead.
+   *
+   * @param name the name of the class which should be loaded to obtain the
+   *             class loader.
+   * @param loader the name of the class loader to use, or <code>null</code>
+   *               if the class loader of the server should be used.
+   * @param data the byte array to be deserialized.
+   * @return the deserialized object stream.
+   * @deprecated {@link #getClassLoader(ObjectName} can be used to obtain
+   *              the named class loader and deserialize the array.
+   * @throws InstanceNotFoundException if the specified class loader is not
+   *                                   registered with the server.
+   * @throws OperationsException if any I/O error is thrown by the
+   *                             deserialization process.
+   * @throws ReflectionException if an error occurs in obtaining the
+   *                             {@link Class} instance.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, loader,
+   *                           "getClassLoader")</code>
+   */
+  ObjectInputStream deserialize(String name, ObjectName loader, byte[] data)
+    throws InstanceNotFoundException, ReflectionException,
+	   OperationsException;
+
+  /**
+   * Returns the value of the supplied attribute from the specified
+   * management bean.
+   *
+   * @param bean the bean to retrieve the value from.
+   * @param name the name of the attribute to retrieve.
+   * @return the value of the attribute.
+   * @throws AttributeNotFoundException if the attribute could not be
+   *                                    accessed from the bean.
+   * @throws MBeanException if the management bean's accessor throws
+   *                        an exception.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception was thrown in trying
+   *                             to invoke the bean's accessor.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, name, bean,
+   *                           "getAttribute")</code>}.
+   * @see DynamicMBean#getAttribute(String)
+   */
+  Object getAttribute(ObjectName bean, String name)
+    throws MBeanException, AttributeNotFoundException,
+	   InstanceNotFoundException, ReflectionException;
+
+  /**
+   * Returns the values of the named attributes from the specified
+   * management bean.
+   *
+   * @param bean the bean to retrieve the value from.
+   * @param names the names of the attributes to retrieve.
+   * @return the values of the attributes.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception was thrown in trying
+   *                             to invoke the bean's accessor.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, bean,
+   *                           "getAttribute")</code>}.  Additionally,
+   *                           for an attribute name, <code>n</code>, the
+   *                           caller's permission must imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, n, bean,
+   *                           "getAttribute")</code>} or that attribute will
+   *                           not be included.
+   *                           
+   * @see DynamicMBean#getAttributes(String[])
+   */
+  AttributeList getAttributes(ObjectName bean, String[] names)
+    throws InstanceNotFoundException, ReflectionException;
+
+  /**
+   * Returns the specified class loader.  If the specified value is
+   * <code>null</code>, then the class loader of the server will be
+   * returned.  If <code>l</code> is the requested class loader,
+   * and <code>r</code> is the actual class loader returned, then
+   * either <code>l</code> and <code>r</code> will be identical,
+   * or they will at least return the same class from
+   * {@link ClassLoader#loadClass(String)} for any given string.
+   * They may not be identical due to one or the other
+   * being wrapped in another class loader (e.g. for security).
+   *
+   * @param name the name of the class loader to return.
+   * @return the class loader.
+   * @throws InstanceNotFoundException if the class loader can not
+   *                                   be found.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "getClassLoader")</code>
+   */
+  ClassLoader getClassLoader(ObjectName name)
+    throws InstanceNotFoundException;
+ 
+  /**
+   * Returns the class loader of the specified management bean.  If
+   * <code>l</code> is the requested class loader, and <code>r</code>
+   * is the actual class loader returned, then either <code>l</code>
+   * and <code>r</code> will be identical, or they will at least
+   * return the same class from {@link ClassLoader#loadClass(String)}
+   * for any given string.  They may not be identical due to one or
+   * the other being wrapped in another class loader (e.g. for
+   * security).
+   *
+   * @param name the name of the bean whose class loader should be
+   *             returned.
+   * @return the class loader.
+   * @throws InstanceNotFoundException if the bean is not registered
+   *                                   with the server.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "getClassLoaderFor")</code>
+   */
+  ClassLoader getClassLoaderFor(ObjectName name)
+    throws InstanceNotFoundException;
+
+  /**
+   * Returns the class loader repository used by this server.
+   *
+   * @return the class loader repository.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(null, null, null,
+   *                           "getClassLoaderRepository")</code>
+   */
+  ClassLoaderRepository getClassLoaderRepository();
+
+  /**
+   * Returns the default domain this server applies to beans that have
+   * no specified domain.
+   *
+   * @return the default domain.
+   */
+  String getDefaultDomain();
+
+  /**
+   * Returns an array containing all the domains used by beans registered
+   * with this server.  The ordering of the array is undefined.
+   *
+   * @return the list of domains.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(null, null, name,
+   *                           "getDomains")</code>}.  Additionally,
+   *                           for an domain, <code>d</code>, the
+   *                           caller's permission must imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(null, null,
+   *                           new ObjectName("d:x=x"), "getDomains")</code>}
+   *                           or that domain will not be included.  Note
+   *                           that "x=x" is an arbitrary key-value pair
+   *                           provided to satisfy the constructor.
+   * @see ObjectName#getDomain()
+   */
+  String[] getDomains();
+
+  /**
+   * Returns the number of management beans registered with this server.
+   * This may be less than the real number if the caller's access is
+   * restricted.
+   *
+   * @return the number of registered beans.
+   */
+  Integer getMBeanCount();
+
+  /**
+   * Returns information on the given management bean.
+   *
+   * @param name the name of the management bean.
+   * @return an instance of {@link MBeanInfo} for the bean.
+   * @throws IntrospectionException if an exception occurs in examining
+   *                                the bean.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception occurs when trying
+   *                             to invoke {@link DynamicMBean#getMBeanInfo()}
+   *                             on the bean.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "getMBeanInfo")</code>}.
+   * @see DynamicMBean#getMBeanInfo()
+   */
+  MBeanInfo getMBeanInfo(ObjectName name)
+    throws InstanceNotFoundException, IntrospectionException,
+	   ReflectionException;
+
+  /**
+   * Returns the {@link ObjectInstance} created for the specified
+   * management bean on registration.
+   *
+   * @param name the name of the bean.
+   * @return the corresponding {@link ObjectInstance} instance.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "getObjectInstance")</code>
+   * @see #createMBean(String, ObjectName)
+   */
+  ObjectInstance getObjectInstance(ObjectName name)
+    throws InstanceNotFoundException;
+
+  /**
+   * <p>
+   * Creates an instance of the specified class using the list of
+   * class loaders from the {@link
+   * javax.management.loading.ClassLoaderRepository Class Loader
+   * Repository}.  The class should have a public constructor
+   * with no arguments.  A reference to the new instance is returned,
+   * but the instance is not yet registered with the server.
+   * </p>
+   * <p>
+   * This method is equivalent to calling {@link 
+   * #instantiate(String, Object[], String[])
+   * <code>instantiate(name, (Object[]) null, (String[]) null)</code>}
+   * with <code>null</code> parameters and signature.
+   * </p>
+   *
+   * @param name the name of the class of bean to be instantiated.
+   * @return an instance of the given class.
+   * @throws ReflectionException if an exception is thrown during
+   *                             loading the class or calling the
+   *                             constructor.
+   * @throws MBeanException if the constructor throws an exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, null,
+   *                           "instantiate")</code>}.
+   * @see #instantiate(String, Object[], String[])
+   */
+  Object instantiate(String name)
+    throws ReflectionException, MBeanException;
+
+  /**
+   * Creates an instance of the specified class using the list of
+   * class loaders from the {@link
+   * javax.management.loading.ClassLoaderRepository Class Loader
+   * Repository}.  The class should have a public constructor
+   * matching the supplied signature.  A reference to the new
+   * instance is returned, but the instance is not yet
+   * registered with the server.
+   *
+   * @param name the name of the class of bean to be instantiated.
+   * @param params the parameters for the constructor.
+   * @param sig the signature of the constructor.
+   * @return an instance of the given class.
+   * @throws ReflectionException if an exception is thrown during
+   *                             loading the class or calling the
+   *                             constructor.
+   * @throws MBeanException if the constructor throws an exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, null,
+   *                           "instantiate")</code>}.
+   */
+  Object instantiate(String name, Object[] params, String[] sig)
+    throws ReflectionException, MBeanException;
+
+  /**
+   * <p>
+   * Creates an instance of the specified class using the supplied
+   * class loader.  If the class loader given is <code>null</code>,
+   * then the class loader of the server will be used.  The class
+   * should have a public constructor with no arguments.  A reference
+   * to the new instance is returned, but the instance is not yet
+   * registered with the server.
+   * </p>
+   * <p>
+   * This method is equivalent to calling {@link 
+   * #instantiate(String, ObjectName, Object[], String[])
+   * <code>instantiate(name, loaderName, (Object[]) null,
+   * (String[]) null)</code>} with <code>null</code> parameters
+   * and signature.
+   * </p>
+   *
+   * @param name the name of the class of bean to be instantiated.
+   * @param loaderName the name of the class loader to use.
+   * @return an instance of the given class.
+   * @throws InstanceNotFoundException if the class loader is not
+   *                                   registered with the server.
+   * @throws ReflectionException if an exception is thrown during
+   *                             loading the class or calling the
+   *                             constructor.
+   * @throws MBeanException if the constructor throws an exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, null,
+   *                           "instantiate")</code>}.
+   * @see #instantiate(String, Object[], String[])
+   */
+  Object instantiate(String name, ObjectName loaderName)
+    throws InstanceNotFoundException, ReflectionException,
+	   MBeanException;
+
+  /**
+   * Creates an instance of the specified class using the supplied
+   * class loader.  If the class loader given is <code>null</code>,
+   * then the class loader of the server will be used.  The class
+   * should have a public constructor matching the supplied
+   * signature.  A reference to the new instance is returned,
+   * but the instance is not yet registered with the server.
+   *
+   * @param name the name of the class of bean to be instantiated.
+   * @param loaderName the name of the class loader to use.
+   * @param params the parameters for the constructor.
+   * @param sig the signature of the constructor.
+   * @return an instance of the given class.
+   * @throws InstanceNotFoundException if the class loader is not
+   *                                   registered with the server.
+   * @throws ReflectionException if an exception is thrown during
+   *                             loading the class or calling the
+   *                             constructor.
+   * @throws MBeanException if the constructor throws an exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, null,
+   *                           "instantiate")</code>}.
+   */
+  Object instantiate(String name, ObjectName loaderName,
+		     Object[] params, String[] sig)
+    throws InstanceNotFoundException, ReflectionException,
+	   MBeanException;
+
+  /**
+   * Invokes the supplied operation on the specified management
+   * bean.  The class objects specified in the signature are loaded
+   * using the same class loader as was used for the management bean.
+   *
+   * @param bean the management bean whose operation should be invoked.
+   * @param name the name of the operation to invoke.
+   * @param params the parameters of the operation.
+   * @param sig the signature of the operation.
+   * @return the return value of the method.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws MBeanException if the method invoked throws an exception.
+   * @throws ReflectionException if an exception is thrown in invoking the
+   *                             method.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, name, bean,
+   *                           "invoke")</code>}.
+   * @see DynamicMBean#invoke(String, Object[], String[])
+   */
+  Object invoke(ObjectName bean, String name, Object[] params, String[] sig)
+    throws InstanceNotFoundException, MBeanException,
+	   ReflectionException;
+
+  /**
+   * <p>
+   * Returns true if the specified management bean is an instance
+   * of the supplied class.
+   * </p>
+   * <p>
+   * A bean, B, is an instance of a class, C, if either of the following
+   * conditions holds:
+   * </p>
+   * <ul>
+   * <li>The class name in B's {@link MBeanInfo} is equal to the supplied
+   * name.</li>
+   * <li>Both the class of B and C were loaded by the same class loader,
+   * and B is assignable to C.</li>
+   * </ul>
+   * 
+   * @param name the name of the management bean.
+   * @param className the name of the class to test if <code>name</code> is
+   *                  an instance of.
+   * @return true if either B is directly an instance of the named class,
+   *         or B is assignable to the class, given that both it and B's
+   *         current class were loaded using the same class loader.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "isInstanceOf")</code>
+   */
+  boolean isInstanceOf(ObjectName name, String className)
+    throws InstanceNotFoundException;
+
+  /**
+   * Returns true if the specified management bean is registered with
+   * the server.
+   *
+   * @param name the name of the management bean.
+   * @return true if the bean is registered.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean name.
+   */
+  boolean isRegistered(ObjectName name);
+
+  /**
+   * <p>
+   * Returns a set of {@link ObjectInstance}s matching the specified
+   * criteria.  The full set of beans registered with the server
+   * are passed through two filters:
+   * </p>
+   * <ol>
+   * <li>Pattern matching is performed using the supplied
+   * {@link ObjectName}.</li>
+   * <li>The supplied query expression is applied.</li>
+   * </ol>
+   * <p>
+   * If both the object name and the query expression are <code>null</code>,
+   * or the object name has no domain and no key properties,
+   * no filtering will be performed and all beans are returned. 
+   * </p>
+   *
+   * @param name an {@link ObjectName} to use as a filter.
+   * @param query a query expression to apply to each of the beans that match
+   *              the given object name.
+   * @return a set of {@link ObjectInstance}s matching the filtered beans.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(null, null, name,
+   *                           "queryMBeans")</code>}.  Additionally,
+   *                           for an bean, <code>b</code>, the
+   *                           caller's permission must imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, b, name,
+   *                           "queryMBeans")</code>} or that bean will
+   *                           not be included.  Such an exception may also
+   *                           arise from the execution of the query, in which
+   *                           case that particular bean will again be excluded.
+   */
+  Set queryMBeans(ObjectName name, QueryExp query);
+  
+  /**
+   * <p>
+   * Returns a set of {@link ObjectName}s matching the specified
+   * criteria.  The full set of beans registered with the server
+   * are passed through two filters:
+   * </p>
+   * <ol>
+   * <li>Pattern matching is performed using the supplied
+   * {@link ObjectName}.</li>
+   * <li>The supplied query expression is applied.</li>
+   * </ol>
+   * <p>
+   * If both the object name and the query expression are <code>null</code>,
+   * or the object name has no domain and no key properties,
+   * no filtering will be performed and all beans are returned. 
+   * </p>
+   *
+   * @param name an {@link ObjectName} to use as a filter.
+   * @param query a query expression to apply to each of the beans that match
+   *              the given object name.
+   * @return a set of {@link ObjectName}s matching the filtered beans.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(null, null, name,
+   *                           "queryNames")</code>}.  Additionally,
+   *                           for an name, <code>n</code>, the
+   *                           caller's permission must imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, n, name,
+   *                           "queryNames")</code>} or that name will
+   *                           not be included.  Such an exception may also
+   *                           arise from the execution of the query, in which
+   *                           case that particular bean will again be excluded.
+   *                           Note that these permissions are implied if the
+   *                           <code>queryMBeans</code> permissions are available.
+   */
+  Set queryNames(ObjectName name, QueryExp query);
+
+  /**
+   * Registers the supplied instance with the server, using the specified
+   * {@link ObjectName}.  If the name given is <code>null</code>, then
+   * the bean supplied is expected to implement the {@link MBeanRegistration}
+   * interface and provide the name via the 
+   * {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface.
+   *
+   * @param obj the object to register with the server.
+   * @param name the name under which to register the object,
+   *             or <code>null</code> if the {@link MBeanRegistration}
+   *             interface should be used.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> object.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "registerMBean")</code>}.  <code>className</code>
+   *                           here corresponds to the result of
+   *                           {@link MBeanInfo#getClassName()} for objects of
+   *                           this class.  If this check succeeds, a check
+   *                           is also made on its
+   *                           {@link java.security.ProtectionDomain} to ensure
+   *                           it implies {@link MBeanTrustPermission(String)
+   *                           <code>MBeanTrustPermission("register")</code>}.
+   *                           The use of the {@link MBeanRegistration} interface
+   *                           results in another {@link MBeanPermission} check
+   *                           being made on the returned {@link ObjectName}.
+   */
+  ObjectInstance registerMBean(Object obj, ObjectName name)
+    throws InstanceAlreadyExistsException, MBeanRegistrationException,
+	   NotCompliantMBeanException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  This includes all
+   * combinations of filters and passback objects registered for
+   * this listener.  For more specific removal of listeners, see
+   * {@link #removeNotificationListener(ObjectName,
+   * NotificationListener,NotificationFilter,Object)}
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the listener to remove.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "removeNotificationListener")</code>}.
+   * @see #addNotificationListener(NotificationListener, NotificationFilter,
+   *                               java.lang.Object)
+   * @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
+   */
+  void removeNotificationListener(ObjectName name,
+				  NotificationListener listener)
+    throws InstanceNotFoundException, ListenerNotFoundException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  Only the first instance with
+   * the supplied filter and passback object is removed.
+   * <code>null</code> is used as a valid value for these parameters,
+   * rather than as a way to remove all registration instances for
+   * the specified listener; for this behaviour instead, see
+   * {@link #removeNotificationListener(ObjectName, NotificationListener)}.
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the listener to remove.
+   * @param filter the filter of the listener to remove.
+   * @param passback the passback object of the listener to remove.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "removeNotificationListener")</code>}.
+   * @see #addNotificationListener(ObjectName, NotificationListener,
+   *                               NotificationFilter, Object)
+   * @see NotificationEmitter#removeNotificationListener(NotificationListener,
+   *                                                     NotificationFilter,
+   *                                                     Object)
+   */
+  void removeNotificationListener(ObjectName name,
+				  NotificationListener listener,
+				  NotificationFilter filter,
+				  Object passback)
+    throws InstanceNotFoundException, ListenerNotFoundException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  This includes all
+   * combinations of filters and passback objects registered for
+   * this listener.  For more specific removal of listeners, see
+   * {@link #removeNotificationListener(ObjectName,
+   * ObjectName,NotificationFilter,Object)}
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the name of the listener to remove.
+   * @throws InstanceNotFoundException if a name doesn't match a registered
+   *                                   bean.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "removeNotificationListener")</code>}.
+   * @see #addNotificationListener(NotificationListener, NotificationFilter,
+   *                               java.lang.Object)
+   * @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
+   */
+  void removeNotificationListener(ObjectName name, ObjectName listener)
+    throws InstanceNotFoundException, ListenerNotFoundException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  Only the first instance with
+   * the supplied filter and passback object is removed.
+   * <code>null</code> is used as a valid value for these parameters,
+   * rather than as a way to remove all registration instances for
+   * the specified listener; for this behaviour instead, see
+   * {@link #removeNotificationListener(ObjectName, ObjectName)}.
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the name of the listener to remove.
+   * @param filter the filter of the listener to remove.
+   * @param passback the passback object of the listener to remove.
+   * @throws InstanceNotFoundException if a name doesn't match a registered
+   *                                   bean.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "removeNotificationListener")</code>}.
+   * @see #addNotificationListener(ObjectName, NotificationListener,
+   *                               NotificationFilter, Object)
+   * @see NotificationEmitter#removeNotificationListener(NotificationListener,
+   *                                                     NotificationFilter,
+   *                                                     Object)
+   */
+  void removeNotificationListener(ObjectName name,
+				  ObjectName listener,
+				  NotificationFilter filter,
+				  Object passback)
+    throws InstanceNotFoundException, ListenerNotFoundException;
+
+  /**
+   * Sets the value of the specified attribute of the supplied
+   * management bean.  
+   *
+   * @param name the name of the management bean.
+   * @param attribute the attribute to set.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws AttributeNotFoundException if the attribute does not
+   *                                    correspond to an attribute
+   *                                    of the bean.
+   * @throws InvalidAttributeValueException if the value is invalid
+   *                                        for this particular
+   *                                        attribute of the bean.
+   * @throws MBeanException if setting the attribute causes
+   *                        the bean to throw an exception (which
+   *                        becomes the cause of this exception).
+   * @throws ReflectionException if an exception occurred in trying
+   *                             to use the reflection interface
+   *                             to lookup the attribute.  The
+   *                             thrown exception is the cause of
+   *                             this exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    name.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, name, bean,
+   *                           "setAttribute")</code>}.
+   * @see #getAttribute(ObjectName, String)
+   * @see DynamicMBean#setAttribute(Attribute)
+   */
+  void setAttribute(ObjectName name, Attribute attribute)
+    throws InstanceNotFoundException, AttributeNotFoundException,
+	   InvalidAttributeValueException, MBeanException,
+	   ReflectionException;
+
+  /**
+   * Sets the value of each of the specified attributes
+   * of the supplied management bean to that specified by
+   * the {@link Attribute} object.  The returned list contains
+   * the attributes that were set and their new values.
+   *
+   * @param name the name of the management bean.
+   * @param attributes the attributes to set.
+   * @return a list of the changed attributes.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception occurred in trying
+   *                             to use the reflection interface
+   *                             to lookup the attribute.  The
+   *                             thrown exception is the cause of
+   *                             this exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    list.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, bean,
+   *                           "setAttribute")</code>}.  Additionally,
+   *                           for an attribute name, <code>n</code>, the
+   *                           caller's permission must imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, n, bean,
+   *                           "setAttribute")</code>} or that attribute will
+   *                           not be included.
+   * @see #getAttributes(ObjectName, String[])
+   * @see DynamicMBean#setAttributes(AttributeList)
+   */
+  AttributeList setAttributes(ObjectName name, AttributeList attributes)
+    throws InstanceNotFoundException, ReflectionException;
+
+  /**
+   * Unregisters the specified management bean.  Following this operation,
+   * the bean instance is no longer accessible from the server via this
+   * name.  Prior to unregistering the bean, the
+   * {@link MBeanRegistration#preDeregister()} method will be called if
+   * the bean implements the {@link MBeanRegistration} interface.
+   *
+   * @param name the name of the management bean.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preDeregister
+   *                                    method.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean name or a
+   *                                    request being made to unregister the
+   *                                    {@link MBeanServerDelegate} bean.
+   * @throws SecurityException if a security manager exists and the
+   *                           caller's permissions don't imply {@link
+   *                           MBeanPermission(String,String,ObjectName,String)
+   *                           <code>MBeanPermission(className, null, name,
+   *                           "unregisterMBean")</code>}.
+   */ 
+  void unregisterMBean(ObjectName name)
+    throws InstanceNotFoundException, MBeanRegistrationException;
+
+}
diff --git a/javax/management/MBeanServerConnection.java b/javax/management/MBeanServerConnection.java
new file mode 100644
index 000000000..dff03e8c0
--- /dev/null
+++ b/javax/management/MBeanServerConnection.java
@@ -0,0 +1,768 @@
+/* MBeanServerConnection.java -- Represents a connection to a management server.
+   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;
+
+import java.io.IOException;
+
+import java.util.Set;
+
+/**
+ * This interface represents a communication mechanism which may
+ * be used to access an MBean server, whether this be local or
+ * remote.  The {@link MBeanServer} interface extends this with
+ * additional methods that apply only to local servers.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface MBeanServerConnection
+{
+
+  /**
+   * Registers the supplied listener with the specified management
+   * bean.  Notifications emitted by the management bean are forwarded
+   * to the listener via the server, which will convert any MBean
+   * references in the source to portable {@link ObjectName}
+   * instances.  The notification is otherwise unchanged.
+   *
+   * @param name the name of the management bean with which the listener
+   *             should be registered.
+   * @param listener the listener which will handle notifications from
+   *                 the bean.
+   * @param filter the filter to apply to incoming notifications, or
+   *               <code>null</code> if no filtering should be applied.
+   * @param passback an object to be passed to the listener when a
+   *                 notification is emitted.
+   * @throws InstanceNotFoundException if the name of the management bean
+   *                                   could not be resolved.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #removeNotificationListener(ObjectName, NotificationListener)
+   * @see #removeNotificationListener(ObjectName, NotificationListener,
+   *                                  NotificationFilter, Object)
+   * @see NotificationBroadcaster#addNotificationListener(NotificationListener,
+   *                                                      NotificationFilter,
+   *                                                      Object)
+   */
+  void addNotificationListener(ObjectName name, NotificationListener listener,
+			       NotificationFilter filter, Object passback)
+    throws InstanceNotFoundException, IOException;
+
+  /**
+   * <p>
+   * Registers the supplied listener with the specified management
+   * bean.  Notifications emitted by the management bean are forwarded
+   * to the listener via the server, which will convert any MBean
+   * references in the source to portable {@link ObjectName}
+   * instances.  The notification is otherwise unchanged.  
+   * </p>
+   * <p>
+   * The listener that receives notifications will be the one that is
+   * registered with the given name at the time this method is called.
+   * Even if it later unregisters and ceases to use that name, it will
+   * still receive notifications.
+   * </p>
+   *
+   * @param name the name of the management bean with which the listener
+   *             should be registered.
+   * @param listener the name of the listener which will handle
+   *                 notifications from the bean.
+   * @param filter the filter to apply to incoming notifications, or
+   *               <code>null</code> if no filtering should be applied.
+   * @param passback an object to be passed to the listener when a
+   *                 notification is emitted.
+   * @throws InstanceNotFoundException if the name of the management bean
+   *                                   could not be resolved.
+   * @throws RuntimeOperationsException if the bean associated with the given
+   *                                    object name is not a
+   *                                    {@link NotificationListener}.  This
+   *                                    exception wraps an
+   *                                    {@link IllegalArgumentException}.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #removeNotificationListener(ObjectName, NotificationListener)
+   * @see #removeNotificationListener(ObjectName, NotificationListener,
+   *                                  NotificationFilter, Object)
+   * @see NotificationBroadcaster#addNotificationListener(NotificationListener,
+   *                                                      NotificationFilter,
+   *                                                      Object)
+   */
+  void addNotificationListener(ObjectName name, ObjectName listener,
+			       NotificationFilter filter, Object passback)
+    throws InstanceNotFoundException, RuntimeOperationsException, IOException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the default constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * {@link javax.management.loading.ClassLoaderRepository default
+   * loader repository} of the server. 
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * <p>
+   * This method is equivalent to calling {@link 
+   * #createMBean(String, ObjectName, Object[], String[])
+   * <code>createMBean(className, name, (Object[]) null,
+   * (String[]) null)</code>} with <code>null</code> parameters
+   * and signature.
+   * </p>
+   *
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #createMBean(String, ObjectName, Object[], String[])
+   */
+  ObjectInstance createMBean(String className, ObjectName name)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException, IOException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the given constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * {@link javax.management.loading.ClassLoaderRepository default
+   * loader repository} of the server. 
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * 
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @param params the parameters for the bean's constructor.
+   * @param sig the signature of the constructor to use.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  ObjectInstance createMBean(String className, ObjectName name,
+			     Object[] params, String[] sig)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException, IOException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the default constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * given class loader.  If this argument is <code>null</code>,
+   * then the same class loader as was used to load the server
+   * is used.
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * <p>
+   * This method is equivalent to calling {@link 
+   * #createMBean(String, ObjectName, ObjectName, Object[], String)
+   * <code>createMBean(className, name, loaderName, (Object[]) null,
+   * (String) null)</code>} with <code>null</code> parameters
+   * and signature.
+   * </p>
+   *
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @param loaderName the name of the class loader.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws InstanceNotFoundException if the specified class loader is not
+   *                                   registered with the server.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #createMBean(String, ObjectName, ObjectName, Object[], String[])
+   */
+  ObjectInstance createMBean(String className, ObjectName name, 
+			     ObjectName loaderName)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException, InstanceNotFoundException,
+	   IOException;
+
+  /**
+   * <p>
+   * Instantiates a new instance of the specified management bean
+   * using the given constructor and registers it with the server
+   * under the supplied name.  The class is loaded using the
+   * given class loader.  If this argument is <code>null</code>,
+   * then the same class loader as was used to load the server
+   * is used. 
+   * </p>
+   * <p>
+   * If the name supplied is <code>null</code>, then the bean is
+   * expected to implement the {@link MBeanRegistration} interface.
+   * The {@link MBeanRegistration#preRegister preRegister} method
+   * of this interface will be used to obtain the name in this case.
+   * </p>
+   * 
+   * @param className the class of the management bean, of which
+   *                  an instance should be created.
+   * @param name the name to register the new bean with.
+   * @param loaderName the name of the class loader.
+   * @param params the parameters for the bean's constructor.
+   * @param sig the signature of the constructor to use.
+   * @return an {@link ObjectInstance} containing the {@link ObjectName}
+   *         and Java class name of the created instance.
+   * @throws ReflectionException if an exception occurs in creating
+   *                             an instance of the bean.
+   * @throws InstanceAlreadyExistsException if a matching instance
+   *                                        already exists.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preRegister
+   *                                    method.
+   * @throws MBeanException if the bean's constructor throws an exception.
+   * @throws NotCompliantMBeanException if the created bean is not
+   *                                    compliant with the JMX specification.
+   * @throws InstanceNotFoundException if the specified class loader is not
+   *                                   registered with the server.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> class name or object
+   *                                    name or if the object name is a pattern.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  ObjectInstance createMBean(String className, ObjectName name,
+			     ObjectName loaderName, Object[] params,
+			     String[] sig)
+    throws ReflectionException, InstanceAlreadyExistsException,
+	   MBeanRegistrationException, MBeanException,
+	   NotCompliantMBeanException, InstanceNotFoundException,
+	   IOException;
+
+  /**
+   * Returns the value of the supplied attribute from the specified
+   * management bean.
+   *
+   * @param bean the bean to retrieve the value from.
+   * @param name the name of the attribute to retrieve.
+   * @return the value of the attribute.
+   * @throws AttributeNotFoundException if the attribute could not be
+   *                                    accessed from the bean.
+   * @throws MBeanException if the management bean's accessor throws
+   *                        an exception.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception was thrown in trying
+   *                             to invoke the bean's accessor.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    name.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see DynamicMBean#getAttribute(String)
+   */
+  Object getAttribute(ObjectName bean, String name)
+    throws MBeanException, AttributeNotFoundException,
+	   InstanceNotFoundException, ReflectionException,
+	   IOException;
+
+  /**
+   * Returns the values of the named attributes from the specified
+   * management bean.
+   *
+   * @param bean the bean to retrieve the value from.
+   * @param names the names of the attributes to retrieve.
+   * @return the values of the attributes.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception was thrown in trying
+   *                             to invoke the bean's accessor.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    name.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see DynamicMBean#getAttributes(String[])
+   */
+  AttributeList getAttributes(ObjectName bean, String[] names)
+    throws InstanceNotFoundException, ReflectionException,
+	   IOException;
+
+  /**
+   * Returns the default domain this server applies to beans that have
+   * no specified domain.
+   *
+   * @return the default domain.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  String getDefaultDomain()
+    throws IOException;
+
+  /**
+   * Returns an array containing all the domains used by beans registered
+   * with this server.  The ordering of the array is undefined.
+   *
+   * @return the list of domains.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see ObjectName#getDomain()
+   */
+  String[] getDomains()
+    throws IOException;
+
+  /**
+   * Returns the number of management beans registered with this server.
+   *
+   * @return the number of registered beans.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  Integer getMBeanCount()
+    throws IOException;
+
+  /**
+   * Returns information on the given management bean.
+   *
+   * @param name the name of the management bean.
+   * @return an instance of {@link MBeanInfo} for the bean.
+   * @throws IntrospectionException if an exception occurs in examining
+   *                                the bean.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception occurs when trying
+   *                             to invoke {@link DynamicMBean#getMBeanInfo()}
+   *                             on the bean.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see DynamicMBean#getMBeanInfo()
+   */
+  MBeanInfo getMBeanInfo(ObjectName name)
+    throws InstanceNotFoundException, IntrospectionException,
+	   ReflectionException, IOException;
+
+  /**
+   * Returns the {@link ObjectInstance} created for the specified
+   * management bean on registration.
+   *
+   * @param name the name of the bean.
+   * @return the corresponding {@link ObjectInstance} instance.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #createMBean(String, ObjectName)
+   */
+  ObjectInstance getObjectInstance(ObjectName name)
+    throws InstanceNotFoundException, IOException;
+
+  /**
+   * Invokes the supplied operation on the specified management
+   * bean.  The class objects specified in the signature are loaded
+   * using the same class loader as was used for the management bean.
+   *
+   * @param bean the management bean whose operation should be invoked.
+   * @param name the name of the operation to invoke.
+   * @param params the parameters of the operation.
+   * @param sig the signature of the operation.
+   * @return the return value of the method.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws MBeanException if the method invoked throws an exception.
+   * @throws ReflectionException if an exception is thrown in invoking the
+   *                             method.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see DynamicMBean#invoke(String, Object[], String[])
+   */
+  Object invoke(ObjectName bean, String name, Object[] params, String[] sig)
+    throws InstanceNotFoundException, MBeanException,
+	   ReflectionException, IOException;
+
+  /**
+   * <p>
+   * Returns true if the specified management bean is an instance
+   * of the supplied class.
+   * </p>
+   * <p>
+   * A bean, B, is an instance of a class, C, if either of the following
+   * conditions holds:
+   * </p>
+   * <ul>
+   * <li>The class name in B's {@link MBeanInfo} is equal to the supplied
+   * name.</li>
+   * <li>Both the class of B and C were loaded by the same class loader,
+   * and B is assignable to C.</li>
+   * </ul>
+   * 
+   * @param name the name of the management bean.
+   * @param className the name of the class to test if <code>name</code> is
+   *                  an instance of.
+   * @return true if either B is directly an instance of the named class,
+   *         or B is assignable to the class, given that both it and B's
+   *         current class were loaded using the same class loader.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  boolean isInstanceOf(ObjectName name, String className)
+    throws InstanceNotFoundException, IOException;
+
+  /**
+   * Returns true if the specified management bean is registered with
+   * the server.
+   *
+   * @param name the name of the management bean.
+   * @return true if the bean is registered.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean name.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  boolean isRegistered(ObjectName name)
+    throws IOException;
+
+  /**
+   * <p>
+   * Returns a set of {@link ObjectInstance}s matching the specified
+   * criteria.  The full set of beans registered with the server
+   * are passed through two filters:
+   * </p>
+   * <ol>
+   * <li>Pattern matching is performed using the supplied
+   * {@link ObjectName}.</li>
+   * <li>The supplied query expression is applied.</li>
+   * </ol>
+   * <p>
+   * If both the object name and the query expression are <code>null</code>,
+   * or the object name has no domain and no key properties,
+   * no filtering will be performed and all beans are returned. 
+   * </p>
+   *
+   * @param name an {@link ObjectName} to use as a filter.
+   * @param query a query expression to apply to each of the beans that match
+   *              the given object name.
+   * @return a set of {@link ObjectInstance}s matching the filtered beans.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  Set queryMBeans(ObjectName name, QueryExp query)
+    throws IOException;
+  
+  /**
+   * <p>
+   * Returns a set of {@link ObjectName}s matching the specified
+   * criteria.  The full set of beans registered with the server
+   * are passed through two filters:
+   * </p>
+   * <ol>
+   * <li>Pattern matching is performed using the supplied
+   * {@link ObjectName}.</li>
+   * <li>The supplied query expression is applied.</li>
+   * </ol>
+   * <p>
+   * If both the object name and the query expression are <code>null</code>,
+   * or the object name has no domain and no key properties,
+   * no filtering will be performed and all beans are returned. 
+   * </p>
+   *
+   * @param name an {@link ObjectName} to use as a filter.
+   * @param query a query expression to apply to each of the beans that match
+   *              the given object name.
+   * @return a set of {@link ObjectName}s matching the filtered beans.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */
+  Set queryNames(ObjectName name, QueryExp query)
+    throws IOException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  This includes all
+   * combinations of filters and passback objects registered for
+   * this listener.  For more specific removal of listeners, see
+   * {@link #removeNotificationListener(ObjectName,
+   * NotificationListener,NotificationFilter,Object)}
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the listener to remove.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #addNotificationListener(NotificationListener, NotificationFilter,
+   *                               java.lang.Object)
+   * @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
+   */
+  void removeNotificationListener(ObjectName name,
+				  NotificationListener listener)
+    throws InstanceNotFoundException, ListenerNotFoundException,
+	   IOException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  Only the first instance with
+   * the supplied filter and passback object is removed.
+   * <code>null</code> is used as a valid value for these parameters,
+   * rather than as a way to remove all registration instances for
+   * the specified listener; for this behaviour instead, see
+   * {@link #removeNotificationListener(ObjectName, NotificationListener)}.
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the listener to remove.
+   * @param filter the filter of the listener to remove.
+   * @param passback the passback object of the listener to remove.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #addNotificationListener(ObjectName, NotificationListener,
+   *                               NotificationFilter, Object)
+   * @see NotificationEmitter#removeNotificationListener(NotificationListener,
+   *                                                     NotificationFilter,
+   *                                                     Object)
+   */
+  void removeNotificationListener(ObjectName name,
+				  NotificationListener listener,
+				  NotificationFilter filter,
+				  Object passback)
+    throws InstanceNotFoundException, ListenerNotFoundException,
+	   IOException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  This includes all
+   * combinations of filters and passback objects registered for
+   * this listener.  For more specific removal of listeners, see
+   * {@link #removeNotificationListener(ObjectName,
+   * ObjectName,NotificationFilter,Object)}
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the name of the listener to remove.
+   * @throws InstanceNotFoundException if a name doesn't match a registered
+   *                                   bean.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #addNotificationListener(NotificationListener, NotificationFilter,
+   *                               java.lang.Object)
+   * @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
+   */
+  void removeNotificationListener(ObjectName name, ObjectName listener)
+    throws InstanceNotFoundException, ListenerNotFoundException,
+	   IOException;
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from the supplied bean.  Only the first instance with
+   * the supplied filter and passback object is removed.
+   * <code>null</code> is used as a valid value for these parameters,
+   * rather than as a way to remove all registration instances for
+   * the specified listener; for this behaviour instead, see
+   * {@link #removeNotificationListener(ObjectName, ObjectName)}.
+   *
+   * @param name the name of the management bean from which the
+   *             listener should be removed.
+   * @param listener the name of the listener to remove.
+   * @param filter the filter of the listener to remove.
+   * @param passback the passback object of the listener to remove.
+   * @throws InstanceNotFoundException if a name doesn't match a registered
+   *                                   bean.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with the bean.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #addNotificationListener(ObjectName, NotificationListener,
+   *                               NotificationFilter, Object)
+   * @see NotificationEmitter#removeNotificationListener(NotificationListener,
+   *                                                     NotificationFilter,
+   *                                                     Object)
+   */
+  void removeNotificationListener(ObjectName name,
+				  ObjectName listener,
+				  NotificationFilter filter,
+				  Object passback)
+    throws InstanceNotFoundException, ListenerNotFoundException,
+	   IOException;
+
+  /**
+   * Sets the value of the specified attribute of the supplied
+   * management bean.  
+   *
+   * @param name the name of the management bean.
+   * @param attribute the attribute to set.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws AttributeNotFoundException if the attribute does not
+   *                                    correspond to an attribute
+   *                                    of the bean.
+   * @throws InvalidAttributeValueException if the value is invalid
+   *                                        for this particular
+   *                                        attribute of the bean.
+   * @throws MBeanException if setting the attribute causes
+   *                        the bean to throw an exception (which
+   *                        becomes the cause of this exception).
+   * @throws ReflectionException if an exception occurred in trying
+   *                             to use the reflection interface
+   *                             to lookup the attribute.  The
+   *                             thrown exception is the cause of
+   *                             this exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    name.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #getAttribute(ObjectName, String)
+   * @see DynamicMBean#setAttribute(Attribute)
+   */
+  void setAttribute(ObjectName name, Attribute attribute)
+    throws InstanceNotFoundException, AttributeNotFoundException,
+	   InvalidAttributeValueException, MBeanException,
+	   ReflectionException, IOException;
+
+  /**
+   * Sets the value of each of the specified attributes
+   * of the supplied management bean to that specified by
+   * the {@link Attribute} object.  The returned list contains
+   * the attributes that were set and their new values.
+   *
+   * @param name the name of the management bean.
+   * @param attributes the attributes to set.
+   * @return a list of the changed attributes.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws ReflectionException if an exception occurred in trying
+   *                             to use the reflection interface
+   *                             to lookup the attribute.  The
+   *                             thrown exception is the cause of
+   *                             this exception.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean or attribute
+   *                                    list.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   * @see #getAttributes(ObjectName, String[])
+   * @see DynamicMBean#setAttributes(AttributeList)
+   */
+  AttributeList setAttributes(ObjectName name, AttributeList attributes)
+    throws InstanceNotFoundException, ReflectionException,
+	   IOException;
+
+  /**
+   * Unregisters the specified management bean.  Following this operation,
+   * the bean instance is no longer accessible from the server via this
+   * name.  Prior to unregistering the bean, the
+   * {@link MBeanRegistration#preDeregister()} method will be called if
+   * the bean implements the {@link MBeanRegistration} interface.
+   *
+   * @param name the name of the management bean.
+   * @throws InstanceNotFoundException if the bean can not be found.
+   * @throws MBeanRegistrationException if an exception occurs in
+   *                                    calling the preDeregister
+   *                                    method.
+   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
+   *                                    is thrown by the server due to a
+   *                                    <code>null</code> bean name or a
+   *                                    request being made to unregister the
+   *                                    {@link MBeanServerDelegate} bean.
+   * @throws IOException if an I/O error occurred in communicating with
+   *                     the bean server.
+   */ 
+  void unregisterMBean(ObjectName name)
+    throws InstanceNotFoundException, MBeanRegistrationException,
+	   IOException;
+
+}
diff --git a/javax/management/MBeanServerDelegate.java b/javax/management/MBeanServerDelegate.java
new file mode 100644
index 000000000..bf3f5f894
--- /dev/null
+++ b/javax/management/MBeanServerDelegate.java
@@ -0,0 +1,308 @@
+/* MBeanServerDelegate.java -- The management server delegate.
+   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;
+
+import gnu.classpath.ListenerData;
+import gnu.classpath.SystemProperties;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Provides an implementation of a delegate bean, which is associated
+ * with a management server.  The delegate bean is responsible
+ * for providing metadata about the server and handling the
+ * registration and deregistration notifications.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class MBeanServerDelegate
+  implements MBeanServerDelegateMBean, NotificationEmitter
+{
+
+  /**
+   * The identifier of the server associated with this delegate.
+   */
+  private String id;
+
+  /**
+   * The listeners registered with the delegate.
+   */
+  private List listeners;
+
+  /**
+   * The sequence identifier used by the delegate.
+   */
+  private long seqNo;
+
+  /**
+   * Default constructor which generates the id.
+   */
+  public MBeanServerDelegate()
+  {
+    String hostName;
+    try
+      {
+        hostName = InetAddress.getLocalHost().getHostName();
+      }
+    catch (UnknownHostException e)
+      {
+        hostName = "Unknown host";
+      }
+    id = hostName + "_" + new Date().getTime();
+  }
+
+  /**
+   * Registers the specified listener as a new recipient of
+   * notifications from the delegate.  If non-null, the filter
+   * argument will be used to select which notifications are
+   * delivered.  The supplied object will also be passed to
+   * the recipient with each notification.  This should not
+   * be modified by the broadcaster, but instead should be
+   * passed unmodified to the listener.
+   *
+   * @param listener the new listener, who will receive
+   *                 notifications from this broadcasting bean.
+   * @param filter a filter to determine which notifications are
+   *               delivered to the listener, or <code>null</code>
+   *               if no filtering is required.
+   * @param passback an object to be passed to the listener with
+   *                 each notification.
+   * @throws IllegalArgumentException if <code>listener</code> is
+   *                                  <code>null</code>.
+   * @see #removeNotificationListener(NotificationListener)
+   */
+  public void addNotificationListener(NotificationListener listener,
+				      NotificationFilter filter,
+				      Object passback)
+    throws IllegalArgumentException
+  {
+    if (listener == null)
+      throw new IllegalArgumentException("A null listener was supplied.");
+    if (listeners == null)
+      listeners = new ArrayList();
+    listeners.add(new ListenerData(listener, filter, passback));
+  }
+
+  /**
+   * Returns the name of this Java Management eXtensions (JMX) implementation.
+   *
+   * @return the implementation name.
+   */
+  public String getImplementationName()
+  {
+    return "GNU JMX";
+  }
+
+  /**
+   * Returns the vendor of this Java Management eXtensions (JMX) implementation.
+   *
+   * @return the implementation vendor.
+   */
+  public String getImplementationVendor()
+  {
+    return "The GNU Classpath Project";
+  }
+
+  /**
+   * Returns the version of this Java Management eXtensions (JMX) implementation.
+   *
+   * @return the implementation version.
+   */
+  public String getImplementationVersion()
+  {
+    return SystemProperties.getProperty("gnu.classpath.version");
+  }
+
+  /**
+   * Returns the unique identifier for this management server.
+   *
+   * @return the unique id of the server.
+   */
+  public String getMBeanServerId()
+  {
+    return id;
+  }
+
+  /**
+   * Returns an array describing the notifications this
+   * bean may send to its registered listeners.  Ideally, this
+   * array should be complete, but in some cases, this may
+   * not be possible.  However, be aware that some listeners
+   * may expect this to be so.
+   *
+   * @return the array of possible notifications.
+   */
+  public MBeanNotificationInfo[] getNotificationInfo()
+  {
+    return new MBeanNotificationInfo[] 
+      {
+	new MBeanNotificationInfo(new String[]
+	  {
+	    MBeanServerNotification.REGISTRATION_NOTIFICATION,
+	    MBeanServerNotification.UNREGISTRATION_NOTIFICATION,
+	  },
+				  MBeanServerNotification.class.getName(),
+				  "Server registration notifications")
+      };
+  }
+
+  /**
+   * Returns the name of this Java Management eXtensions (JMX) specification.
+   *
+   * @return the specification name.
+   */
+  public String getSpecificationName()
+  {
+    return "JMX";
+  }
+
+
+  /**
+   * Returns the vendor of this Java Management eXtensions (JMX) specification.
+   *
+   * @return the specification vendor.
+   */
+  public String getSpecificationVendor()
+  {
+    return "Sun Microsystems";
+  }
+
+  /**
+   * Returns the version of this Java Management eXtensions (JMX) specification.
+   *
+   * @return the specification version.
+   */
+  public String getSpecificationVersion()
+  {
+    return "1.2";
+  }
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from this bean.  This includes all combinations
+   * of filters and passback objects registered for this listener.
+   * For more specific removal of listeners, see
+   * {@link #removeNotificationListener(NotificationListener,
+   * NotificationFilter, java.lang.Object)}
+   *
+   * @param listener the listener to remove.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with this bean.
+   * @see #addNotificationListener(NotificationListener, NotificationFilter,
+   *                               java.lang.Object)
+   */
+  public void removeNotificationListener(NotificationListener listener)
+    throws ListenerNotFoundException
+  {
+    Iterator it = listeners.iterator();
+    boolean foundOne = false;
+    while (it.hasNext())
+      {
+	ListenerData data = (ListenerData) it.next();
+	if (data.getListener() == listener)
+	  {
+	    it.remove();
+	    foundOne = true;
+	  }
+      }
+    if (!foundOne)
+      throw new ListenerNotFoundException("The specified listener, " + listener +
+					  "is not registered with this bean.");
+  }
+
+  /**
+   * Removes the specified listener from the list of recipients
+   * of notifications from this delegate.  Only the first instance with
+   * the supplied filter and passback object is removed.
+   * <code>null</code> is used as a valid value for these parameters,
+   * rather than as a way to remove all registration instances for
+   * the specified listener; for this behaviour instead, see
+   * {@link #removeNotificationListener(NotificationListener)}.
+   *
+   * @param listener the listener to remove.
+   * @param filter the filter of the listener to remove.
+   * @param passback the passback object of the listener to remove.
+   * @throws ListenerNotFoundException if the specified listener
+   *                                   is not registered with this bean.
+   * @see #addNotificationListener(NotificationListener, NotificationFilter,
+   *                               java.lang.Object)
+   * @see #removeNotificationListener(NotificationListener)
+   */
+  public void removeNotificationListener(NotificationListener listener,
+					 NotificationFilter filter,
+					 Object passback)
+    throws ListenerNotFoundException
+  {
+    if (!(listeners.remove(new ListenerData(listener, filter, passback))))
+      {
+	throw new ListenerNotFoundException("The specified listener, " + listener +
+					    " with filter " + filter + 
+					    "and passback " + passback + 
+					    ", is not registered with this bean.");
+      }
+  }
+
+  /**
+   * Allows the server to use the delegate to send a notification.
+   * If the supplied notification has a sequence number <= 0, then
+   * it is replaced with the delegate's own sequence number.
+   *
+   * @param notification the notification to send.
+   */
+  public void sendNotification(Notification notification)
+  {
+    if (notification.getSequenceNumber() <= 0)
+      notification.setSequenceNumber(++seqNo);
+    Iterator it = listeners.iterator();
+    while (it.hasNext())
+      {
+	ListenerData ldata = (ListenerData) it.next();
+	NotificationFilter filter = ldata.getFilter();
+	if (filter == null || filter.isNotificationEnabled(notification))
+	  ldata.getListener().handleNotification(notification, ldata.getPassback());
+      }
+  }
+
+}
diff --git a/javax/management/MBeanServerDelegateMBean.java b/javax/management/MBeanServerDelegateMBean.java
new file mode 100644
index 000000000..aa7b27300
--- /dev/null
+++ b/javax/management/MBeanServerDelegateMBean.java
@@ -0,0 +1,101 @@
+/* MBeanServerDelegateMBean.java -- The interface of a management server delegate.
+   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;
+
+/**
+ * Defines the interface for the delegate bean associated
+ * with a management server.  The delegate bean is responsible
+ * for providing metadata about the server and handling the
+ * registration and deregistration notifications.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface MBeanServerDelegateMBean
+{
+
+  /**
+   * Returns the name of this Java Management eXtensions (JMX) implementation.
+   *
+   * @return the implementation name.
+   */
+  String getImplementationName();
+
+  /**
+   * Returns the vendor of this Java Management eXtensions (JMX) implementation.
+   *
+   * @return the implementation vendor.
+   */
+  String getImplementationVendor();
+
+  /**
+   * Returns the version of this Java Management eXtensions (JMX) implementation.
+   *
+   * @return the implementation version.
+   */
+  String getImplementationVersion();
+
+  /**
+   * Returns the unique identifier for this management server.
+   *
+   * @return the unique id of the server.
+   */
+  String getMBeanServerId();
+
+  /**
+   * Returns the name of this Java Management eXtensions (JMX) specification.
+   *
+   * @return the specification name.
+   */
+  String getSpecificationName();
+
+  /**
+   * Returns the vendor of this Java Management eXtensions (JMX) specification.
+   *
+   * @return the specification vendor.
+   */
+  String getSpecificationVendor();
+
+  /**
+   * Returns the version of this Java Management eXtensions (JMX) specification.
+   *
+   * @return the specification version.
+   */
+  String getSpecificationVersion();
+
+}
diff --git a/javax/management/MBeanServerNotification.java b/javax/management/MBeanServerNotification.java
new file mode 100644
index 000000000..820fd61b3
--- /dev/null
+++ b/javax/management/MBeanServerNotification.java
@@ -0,0 +1,103 @@
+/* MBeanServerNotification.java -- The registration notification.
+   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;
+
+/**
+ * The notification emitted by a management server on a registration
+ * or de-registration event.  Events are emitted via the delegate
+ * management bean of the server.  Other objects can listen for
+ * such events by registering their interest with the delegate
+ * bean.  The bean can be obtained via the {@link ObjectName}
+ * <code>JMImplementation:type=MBeanServerDelegate</code>.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class MBeanServerNotification
+  extends Notification
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = 2876477500475969677L;
+
+  /**
+   * Notification type for the registration event.
+   */
+  public static final String REGISTRATION_NOTIFICATION = "JMX.mbean.registered";
+
+  /**
+   * Notification type for the de-registration event.
+   */
+  public static final String UNREGISTRATION_NOTIFICATION = "JMX.mbean.unregistered";
+
+  /**
+   * The name of the bean which forms the subject of this notification.
+   */
+  private ObjectName objectName;
+
+  /**
+   * Constructs a new {@link MBeanServerNotification} of the specified
+   * type for an event relating to the supplied bean, with the given
+   * source and sequence number.
+   *
+   * @param type the type of notification (registration or de-registration).
+   * @param source the source of the notification.
+   * @param seqNo the sequence number of this notification, used to order
+   *              multiple such notifications.
+   * @param name the name of the bean concerned by this event.
+   */
+  public MBeanServerNotification(String type, Object source, long seqNo,
+				 ObjectName name)
+  {
+    super(type, source, seqNo);
+    objectName = name;
+  }
+
+  /**
+   * Returns the name of the bean this notification concerns.
+   *
+   * @return the name of the bean.
+   */
+  public ObjectName getMBeanName()
+  {
+    return objectName;
+  }
+
+}
diff --git a/javax/management/ObjectInstance.java b/javax/management/ObjectInstance.java
new file mode 100644
index 000000000..df364cffc
--- /dev/null
+++ b/javax/management/ObjectInstance.java
@@ -0,0 +1,147 @@
+/* ObjectInstance.java -- Represent the bean instance used by a server.
+   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;
+
+import java.io.Serializable;
+
+/**
+ * A simple class used to link a bean instance to its class name.
+ * If the bean is a {@link DynamicMBean}, the class name may be
+ * obtained using {@link MBeanInfo#getClassName()}.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class ObjectInstance
+  implements Serializable
+{
+
+  /**
+   * Compatible with JDK 1.5
+   */
+  private static final long serialVersionUID = -4099952623687795850L;
+
+  /**
+   * The name of the bean.
+   */
+  private ObjectName name;
+
+  /**
+   * The class name of the bean.
+   */
+  private String className;
+
+  /**
+   * Constructs a new {@link ObjectInstance} for the specified bean
+   * with the supplied class name.  The class name should include
+   * the full package name.
+   *
+   * @param name the name of the bean.
+   * @param className the class name of the bean.
+   */
+  public ObjectInstance(ObjectName name, String className)
+  {
+    this.name = name;
+    this.className = className;
+  }
+
+  /**
+   * Constructs a new {@link ObjectInstance} for the specified bean
+   * with the supplied class name.  The class name should include
+   * the full package name.
+   *
+   * @param name the name of the bean.
+   * @param className the class name of the bean.
+   * @throws MalformedObjectNameException if the name of the bean
+   *                                      does not match the syntax
+   *                                      of an {@link ObjectName}.
+   */
+  public ObjectInstance(String name, String className)
+    throws MalformedObjectNameException
+  {
+    this(new ObjectName(name), className);
+  }
+
+  /**
+   * Returns true if the supplied object is also an {@link ObjectInstance}
+   * with the same bean and class name.
+   *
+   * @param obj the object to compare.
+   * @return true if the the supplied object is equal to <code>this</code>.
+   */
+  public boolean equals(Object obj)
+  {
+    if (!(obj instanceof ObjectInstance))
+      return false;
+    ObjectInstance i = (ObjectInstance) obj;
+    return (i.getClassName().equals(className) &&
+	    i.getObjectName().equals(name));
+  }
+
+  /**
+   * Returns the class name of the bean.
+   *
+   * @return the class name.
+   */
+  public String getClassName()
+  {
+    return className;
+  }
+
+  /**
+   * Returns the name of the bean.
+   *
+   * @return the name of the bean.
+   */
+  public ObjectName getObjectName()
+  {
+    return name;
+  }
+
+  /**
+   * Returns a hash code for this instance.  This is calculated as
+   * the sum of the hashcodes for the bean's name and the class name.
+   *
+   * @return the hash code of this instance.
+   */
+  public int hashCode()
+  {
+    return name.hashCode() + className.hashCode();
+  }
+
+}
diff --git a/javax/management/ObjectName.java b/javax/management/ObjectName.java
new file mode 100644
index 000000000..0e6bf2fd9
--- /dev/null
+++ b/javax/management/ObjectName.java
@@ -0,0 +1,775 @@
+/* ObjectName.java -- Represent the name of a bean, or a pattern for a name.
+   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;
+
+import java.io.Serializable;
+
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ * <p>
+ * An {@link ObjectName} instance represents the name of a management
+ * bean, or a pattern which may match the name of one or more
+ * management beans.  Patterns are distinguished from names by the
+ * presence of the '?' and '*' characters (which match a single
+ * character and a series of zero or more characters, respectively).
+ * </p>
+ * <p>
+ * Each name begins with a domain element, which is terminated by
+ * a ':' character.  The domain may be empty.  If so, it will be
+ * replaced by the default domain of the bean server in certain
+ * contexts.  The domain is a pattern, if it contains either '?'
+ * or '*'.  To avoid collisions, it is usual to use reverse
+ * DNS names for the domain, as in Java package and property names.
+ * </p>
+ * <p>
+ * Following the ':' character is a series of properties.  The list
+ * is separated by commas, and largely consists of unordered key-value
+ * pairs, separated by an equals sign ('=').  At most one element may
+ * be an asterisk ('*'), which turns the {@link ObjectName} instance
+ * into a <emph>property pattern</emph>.  In this situation, the pattern
+ * matches a name if the name contains at least those key-value pairs
+ * given and has the same domain.
+ * </p>
+ * <p>
+ * A <emph>key</emph> is a string of characters which doesn't include
+ * any of those used as delimiters or in patterns (':', '=', ',', '?'
+ * and '*').  Keys must be unique.
+ * </p>
+ * <p>
+ * A value may be <emph>quoted</emph> or <emph>unquoted</emph>.  Unquoted
+ * values obey the same rules as given for keys above.  Quoted values are
+ * surrounded by quotation marks ("), and use a backslash ('\') character
+ * to include quotes ('\"'), backslashes ('\\'), newlines ('\n'), and
+ * the pattern characters ('\?' and '\*').  The quotes and backslashes
+ * (after expansion) are considered part of the value.
+ * </p>
+ * <p>
+ * Spaces are maintained within the different parts of the name.  Thus,
+ * '<code>domain: key1 = value1 </code>' has a key ' key1 ' with value
+ * ' value1 '.  Newlines are disallowed, except where escaped in quoted
+ * values.
+ * </p> 
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public class ObjectName
+  implements Serializable, QueryExp
+{
+
+  /**
+   * The domain of the name.
+   */
+  private String domain;
+
+  /**
+   * The properties, as key-value pairs.
+   */
+  private TreeMap properties;
+
+  /**
+   * The properties as a string (stored for ordering).
+   */
+  private String propertyListString;
+
+  /**
+   * True if this object name is a property pattern.
+   */
+  private boolean propertyPattern;
+
+  /**
+   * The management server associated with this object name.
+   */
+  private MBeanServer server;
+
+  /**
+   * Constructs an {@link ObjectName} instance from the given string,
+   * which should be of the form
+   * &lt;domain&gt;:&lt;properties&gt;&lt;wild&gt;.  &lt;domain&gt;
+   * represents the domain section of the name.  &lt;properties&gt;
+   * represents the key-value pairs, as returned by {@link
+   * #getKeyPropertyListString()}.  &lt;wild&gt; is the optional
+   * asterisk present in the property list.  If the string doesn't
+   * represent a property pattern, it will be empty.  If it does,
+   * it will be either ',*' or '*', depending on whether other
+   * properties are present or not, respectively.
+   *
+   * @param name the string to use to construct this instance.
+   * @throws MalformedObjectNameException if the string is of the
+   *                                      wrong format.
+   * @throws NullPointerException if <code>name</code> is
+   *                              <code>null</code>.
+   */
+  public ObjectName(String name)
+    throws MalformedObjectNameException
+  {
+    int domainSep = name.indexOf(':');
+    if (domainSep == -1)
+      throw new MalformedObjectNameException("No domain separator was found.");
+    domain = name.substring(0, domainSep);
+    String rest = name.substring(domainSep + 1);
+    if (rest.equals("*"))
+      propertyPattern = true;
+    else
+      {
+	if (rest.endsWith(",*"))
+	  {
+	    propertyPattern = true;
+	    propertyListString = rest.substring(0, rest.length() - 2);
+	  }
+	else
+	  propertyListString = rest;
+	String[] pairs = propertyListString.split(",");
+	if (pairs.length == 0 && !isPattern())
+	  throw new MalformedObjectNameException("A name that is not a " +
+						 "pattern must contain at " +
+						 "least one key-value pair.");
+	properties = new TreeMap();
+	for (int a = 0; a < pairs.length; ++a)
+	  {
+	    int sep = pairs[a].indexOf('=');
+	    String key = pairs[a].substring(0, sep);
+	    if (properties.containsKey(key))
+	      throw new MalformedObjectNameException("The same key occurs " +
+						     "more than once.");
+	    properties.put(key, pairs[a].substring(sep + 1));
+	  }	
+      }
+    checkComponents();
+  }
+
+  /**
+   * Constructs an {@link ObjectName} instance using the given
+   * domain and the one specified property.
+   *
+   * @param domain the domain part of the object name.
+   * @param key the key of the property.
+   * @param value the value of the property.
+   * @throws MalformedObjectNameException the domain, key or value
+   *                                      contains an illegal
+   *                                      character or the value
+   *                                      does not follow the quoting
+   *                                      specifications.
+   * @throws NullPointerException if one of the parameters is
+   *                              <code>null</code>.
+   */
+  public ObjectName(String domain, String key, String value)
+    throws MalformedObjectNameException
+  {
+    this.domain = domain;
+    properties = new TreeMap();
+    properties.put(key, value);
+    checkComponents();
+  }
+
+  /**
+   * Constructs an {@link ObjectName} instance using the given
+   * domain and properties.
+   *
+   * @param domain the domain part of the object name.
+   * @param properties the key-value property pairs.
+   * @throws MalformedObjectNameException the domain, a key or a value
+   *                                      contains an illegal
+   *                                      character or a value
+   *                                      does not follow the quoting
+   *                                      specifications.
+   * @throws NullPointerException if one of the parameters is
+   *                              <code>null</code>.
+   */
+  public ObjectName(String domain, Hashtable properties)
+    throws MalformedObjectNameException
+  {
+    this.domain = domain;
+    this.properties.putAll(properties);
+    checkComponents();
+  }
+
+  /**
+   * Checks the legality of the domain and the properties.
+   *
+   * @throws MalformedObjectNameException the domain, a key or a value
+   *                                      contains an illegal
+   *                                      character or a value
+   *                                      does not follow the quoting
+   *                                      specifications.
+   */
+  private void checkComponents()
+    throws MalformedObjectNameException
+  {
+    if (domain.indexOf(':') != -1)
+      throw new MalformedObjectNameException("The domain includes a ':' " +
+					     "character.");
+    if (domain.indexOf('\n') != -1)
+      throw new MalformedObjectNameException("The domain includes a newline " +
+					     "character.");
+    char[] chars = new char[] { ':', ',', '*', '?', '=' };
+    Iterator i = properties.entrySet().iterator();
+    while (i.hasNext())
+      {
+	Map.Entry entry = (Map.Entry) i.next();
+	String key = (String) entry.getKey();
+	for (int a = 0; a < chars.length; ++a)
+	  if (key.indexOf(chars[a]) != -1)
+	    throw new MalformedObjectNameException("A key contains a '" +
+						   chars[a] + "' " +
+						   "character.");
+	String value = (String) entry.getValue();
+	int quote = value.indexOf('"');
+	if (quote == 0)
+	  {
+	    try
+	      {
+		unquote(value);
+	      }
+	    catch (IllegalArgumentException e)
+	      {
+		throw new MalformedObjectNameException("The quoted value is " +
+						       "invalid.");
+	      }
+	  }
+	else if (quote != -1)
+	  throw new MalformedObjectNameException("A value contains " +
+						 "a '\"' character.");
+	else
+	  {
+	    for (int a = 0; a < chars.length; ++a)
+	      if (value.indexOf(chars[a]) != -1)
+		throw new MalformedObjectNameException("A value contains " +
+						       "a '" + chars[a] + "' " +
+						       "character.");
+	  }
+      }
+  }
+
+  /**
+   * <p>
+   * Attempts to find a match between this name and the one supplied.
+   * The following criteria are used:
+   * </p>
+   * <ul>
+   * <li>If the supplied name is a pattern, <code>false</code> is
+   * returned.</li>
+   * <li>If this name is a pattern, this method returns <code>true</code>
+   * if the supplied name matches the pattern.</li>
+   * <li>If this name is not a pattern, the result of
+   * <code>equals(name)</code> is returned.
+   * </ul>
+   *
+   * @param name the name to find a match with.
+   * @return true if the name either matches this pattern or is
+   *         equivalent to this name under the criteria of
+   *         {@link #equals(java.lang.Object)}
+   * @throws NullPointerException if <code>name</code> is <code>null</code>.
+   */
+  public boolean apply(ObjectName name)
+  {
+    if (name.isPattern())
+      return false;
+    if (isPattern())
+      {
+	boolean domainMatch, propMatch;
+	if (isDomainPattern())
+	  {
+	    String oDomain = name.getDomain();
+	    int oLength = oDomain.length();
+	    for (int a = 0; a < domain.length(); ++a)
+	      {
+		char n = domain.charAt(a);
+		if (oLength == a && n != '*')
+		  return false;
+		if (n == '?')
+		  continue;
+		if (n == '*')
+		  if ((a + 1) < domain.length())
+		    {
+		      if (oLength == a)
+			return false;
+		      char next;
+		      do
+			{
+			  next = domain.charAt(a + 1);
+			} while (next == '*');
+		      if (next == '?')
+			continue;
+		      int pos = a;
+		      while (oDomain.charAt(pos) != next)
+			{
+			  ++pos;
+			  if (pos == oLength)
+			    return false;
+			}
+		    }
+		if (n != oDomain.charAt(a))
+		  return false;
+	      }
+	    domainMatch = true;
+	  }
+	else
+	  domainMatch = domain.equals(name.getDomain());
+	if (isPropertyPattern())
+	  {
+	    Hashtable oProps = name.getKeyPropertyList();
+	    Iterator i = properties.entrySet().iterator();
+	    while (i.hasNext())
+	      {
+		Map.Entry entry = (Map.Entry) i.next();
+		String key = (String) entry.getKey();
+		if (!(oProps.containsKey(key)))
+		  return false;
+		String val = (String) entry.getValue();
+		if (!(val.equals(oProps.get(key))))
+		  return false;
+	      }
+	    propMatch = true;
+	  }
+	else
+	  propMatch =
+	    getCanonicalKeyPropertyListString().equals
+	    (name.getCanonicalKeyPropertyListString());
+	return domainMatch && propMatch;
+      }
+    return equals(name);
+  }
+
+  /**
+   * Compares the specified object with this one.  The two
+   * are judged to be equivalent if the given object is an
+   * instance of {@link ObjectName} and has an equal canonical
+   * form (as returned by {@link #getCanonicalName()}).
+   *
+   * @param obj the object to compare with this.
+   * @return true if the object is also an {@link ObjectName}
+   *         with an equivalent canonical form.
+   */
+  public boolean equals(Object obj)
+  {
+    if (obj instanceof ObjectName)
+      {
+	ObjectName o = (ObjectName) obj;
+	return getCanonicalName().equals(o.getCanonicalName());
+      }
+    return false;
+  }
+
+  /**
+   * Returns the property list in canonical form.  The keys
+   * are ordered using the lexicographic ordering used by
+   * {@link java.lang.String#compareTo(java.lang.Object)}.
+   * 
+   * @return the property list, with the keys in lexicographic
+   *         order.
+   */
+  public String getCanonicalKeyPropertyListString()
+  {
+    StringBuilder builder = new StringBuilder();
+    Iterator i = properties.entrySet().iterator();
+    while (i.hasNext())
+      {
+	Map.Entry entry = (Map.Entry) i.next();
+	builder.append(entry.getKey() + "=" + entry.getValue());
+	if (i.hasNext())
+	  builder.append(",");
+      }
+    return builder.toString();
+  }
+
+  /**
+   * <p>
+   * Returns the name as a string in canonical form.  More precisely,
+   * this returns a string of the format 
+   * &lt;domain&gt;:&lt;properties&gt;&lt;wild&gt;.  &lt;properties&gt;
+   * is the same value as returned by
+   * {@link #getCanonicalKeyPropertyListString()}.  &lt;wild&gt;
+   * is:
+   * </p>
+   * <ul>
+   * <li>an empty string, if the object name is not a property pattern.</li>
+   * <li>'*' if &lt;properties&gt; is empty.</li>
+   * <li>',*' if there is at least one key-value pair.</li>
+   * </ul>
+   * 
+   * @return the canonical string form of the object name, as specified
+   *         above.
+   */
+  public String getCanonicalName()
+  {
+    return domain + ":" +
+      getCanonicalKeyPropertyListString() +
+      (isPropertyPattern() ? (properties.isEmpty() ? "*" : ",*") : "");
+  }
+
+  /**
+   * Returns the domain part of the object name.
+   *
+   * @return the domain.
+   */
+  public String getDomain()
+  {
+    return domain;
+  }
+
+  /**
+   * Returns an {@link ObjectName} instance that is substitutable for the
+   * one given.  The instance returned may be a subclass of {@link ObjectName},
+   * but is not guaranteed to be of the same type as the given name, if that
+   * should also turn out to be a subclass.  The returned instance may or may
+   * not be equivalent to the one given.  The purpose of this method is to provide
+   * an instance of {@link ObjectName} with a well-defined semantics, such as may
+   * be used in cases where the given name is not trustworthy.
+   *
+   * @param name the {@link ObjectName} to provide a substitute for.
+   * @return a substitute for the given name, which may or may not be a subclass
+   *         of {@link ObjectName}.  In either case, the returned object is
+   *         guaranteed to have the semantics defined here.
+   * @throws NullPointerException if <code>name</code> is <code>null</code>.
+   */
+  public static ObjectName getInstance(ObjectName name)
+  {
+    try
+      {
+	return new ObjectName(name.getCanonicalName());
+      }
+    catch (MalformedObjectNameException e)
+      {
+	throw (InternalError)
+	  (new InternalError("The canonical name of " +
+			     "the given name is invalid.").initCause(e));
+      }
+  }
+
+  /**
+   * Returns an {@link ObjectName} instance for the specified name, represented
+   * as a {@link java.lang.String}.  The instance returned may be a subclass of
+   * {@link ObjectName} and may or may not be equivalent to earlier instances
+   * returned by this method for the same string.
+   *
+   * @param name the {@link ObjectName} to provide an instance of.
+   * @return a instance for the given name, which may or may not be a subclass
+   *         of {@link ObjectName}.  
+   * @throws MalformedObjectNameException the domain, a key or a value
+   *                                      contains an illegal
+   *                                      character or a value
+   *                                      does not follow the quoting
+   *                                      specifications.
+   * @throws NullPointerException if <code>name</code> is <code>null</code>.
+   */
+  public static ObjectName getInstance(String name)
+    throws MalformedObjectNameException
+  {
+    return new ObjectName(name);
+  }
+
+  /**
+   * Returns an {@link ObjectName} instance for the specified name, represented
+   * as a series of {@link java.lang.String} objects for the domain and a single
+   * property, as a key-value pair.  The instance returned may be a subclass of
+   * {@link ObjectName} and may or may not be equivalent to earlier instances
+   * returned by this method for the same parameters.
+   *
+   * @param domain the domain part of the object name.
+   * @param key the key of the property.
+   * @param value the value of the property.
+   * @return a instance for the given name, which may or may not be a subclass
+   *         of {@link ObjectName}.  
+   * @throws MalformedObjectNameException the domain, a key or a value
+   *                                      contains an illegal
+   *                                      character or a value
+   *                                      does not follow the quoting
+   *                                      specifications.
+   * @throws NullPointerException if <code>name</code> is <code>null</code>.
+   */
+  public static ObjectName getInstance(String domain, String key, String value)
+    throws MalformedObjectNameException
+  {
+    return new ObjectName(domain, key, value);
+  }
+
+  /**
+   * Returns an {@link ObjectName} instance for the specified name, represented
+   * as a domain {@link java.lang.String} and a table of properties.  The
+   * instance returned may be a subclass of {@link ObjectName} and may or may
+   * not be equivalent to earlier instances returned by this method for the
+   * same string.
+   *
+   * @param domain the domain part of the object name.
+   * @param properties the key-value property pairs.
+   * @return a instance for the given name, which may or may not be a subclass
+   *         of {@link ObjectName}.  
+   * @throws MalformedObjectNameException the domain, a key or a value
+   *                                      contains an illegal
+   *                                      character or a value
+   *                                      does not follow the quoting
+   *                                      specifications.
+   * @throws NullPointerException if <code>name</code> is <code>null</code>.
+   */
+  public static ObjectName getInstance(String domain, Hashtable properties)
+    throws MalformedObjectNameException
+  {
+    return new ObjectName(domain, properties);
+  }
+
+  /**
+   * Returns the property value corresponding to the given key.
+   *
+   * @param key the key of the property to be obtained.
+   * @return the value of the specified property.
+   * @throws NullPointerException if <code>key</code> is <code>null</code>.
+   */
+  public String getKeyProperty(String key)
+  {
+    if (key == null)
+      throw new NullPointerException("Null key given in request for a value.");
+    return (String) properties.get(key);
+  }
+
+  /**
+   * Returns the properties in a {@link java.util.Hashtable}.  The table
+   * contains each of the properties as keys mapped to their value.  The
+   * returned table may be unmodifiable.  If the case that the table is
+   * modifiable, changes made to it will not be reflected in the object
+   * name.
+   *
+   * @return a {@link java.util.Hashtable}, containing each of the object
+   *         name's properties.
+   */
+  public Hashtable getKeyPropertyList()
+  {
+    return (Hashtable) Collections.unmodifiableMap(new Hashtable(properties));
+  }
+
+  /**
+   * Returns a {@link java.lang.String} representation of the property
+   * list.  If the object name was created using {@link
+   * ObjectName(String)}, then this string will contain the properties
+   * in the same order they were given in at creation.
+   * 
+   * @return the property list.
+   */
+  public String getKeyPropertyListString()
+  {
+    if (propertyListString != null)
+      return propertyListString;
+    return getCanonicalKeyPropertyListString();
+  }
+
+  /**
+   * Returns a hash code for this object name.  This is calculated as the
+   * summation of the hash codes of the domain and the properties.
+   *
+   * @return a hash code for this object name.
+   */
+  public int hashCode()
+  {
+    return domain.hashCode() + properties.hashCode();
+  }
+
+  /**
+   * Returns true if the domain of this object name is a pattern.
+   * This is the case if it contains one or more wildcard characters
+   * ('*' or '?').
+   *
+   * @return true if the domain is a pattern.
+   */
+  public boolean isDomainPattern()
+  {
+    return domain.contains("?") || domain.contains("*");
+  }
+
+  /**
+   * Returns true if this is an object name pattern.  An object
+   * name pattern has a domain containing a wildcard character
+   * ('*' or '?') and/or a '*' in the list of properties.
+   * This method will return true if either {@link #isDomainPattern()}
+   * or {@link #isPropertyPattern()} does.
+   *
+   * @return true if this is an object name pattern.
+   */
+  public boolean isPattern()
+  {
+    return isDomainPattern() || isPropertyPattern();
+  }
+
+  /**
+   * Returns true if this object name is a property pattern.  This is
+   * the case if the list of properties contains an '*'.
+   *
+   * @return true if this is a property pattern.
+   */
+  public boolean isPropertyPattern()
+  {
+    return propertyPattern;
+  }
+
+  /**
+   * <p>
+   * Returns a quoted version of the supplied string.  The string may
+   * contain any character.  The resulting quoted version is guaranteed
+   * to be usable as the value of a property, so this method provides
+   * a good way of ensuring that a value is legal.
+   * </p>
+   * <p>
+   * The string is transformed as follows:
+   * </p>
+   * <ul>
+   * <li>The string is prefixed with an opening quote character, '"'.
+   * <li>For each character, s:
+   * <ul>
+   * <li>If s is a quote ('"'), it is replaced by a backslash
+   * followed by a quote.</li>
+   * <li>If s is a star ('*'), it is replaced by a backslash followed
+   * by a star.</li>
+   * <li>If s is a question mark ('?'), it is replaced by a backslash
+   * followed by a question mark.</li>
+   * <li>If s is a backslash ('\'), it is replaced by two backslashes.</li>
+   * <li>If s is a newline character, it is replaced by a backslash followed by
+   * a '\n'.</li>
+   * <li>Otherwise, s is used verbatim.
+   * </ul></li>
+   * <li>The string is terminated with a closing quote character, '"'.</li>
+   * </ul> 
+   * 
+   * @param string the string to quote.
+   * @return a quoted version of the supplied string.
+   * @throws NullPointerException if <code>string</code> is <code>null</code>.
+   */
+  public static String quote(String string)
+  {
+    StringBuilder builder = new StringBuilder('"');
+    for (int a = 0; a < string.length(); ++a)
+      {
+	char s = string.charAt(a);
+	switch (s)
+	  {
+	  case '"':
+	    builder.append("\\\"");
+	    break;
+	  case '*':
+	    builder.append("\\*");
+	    break;
+	  case '?':
+	    builder.append("\\?");
+	    break;
+	  case '\\':
+	    builder.append("\\\\");
+	    break;
+	  case '\n':
+	    builder.append("\\\n");
+	    break;
+	  default:
+	    builder.append(s);
+	  }
+      }
+    builder.append('"');
+    return builder.toString();
+  }
+
+  /**
+   * Changes the {@link MBeanServer} on which this query is performed.
+   *
+   * @param server the new server to use.
+   */
+  public void setMBeanServer(MBeanServer server)
+  {
+    this.server = server;
+  }
+
+  /**
+   * Returns a textual representation of the object name.
+   * The format is unspecified, but it should be expected that
+   * two equivalent object names will return the same string
+   * from this method.
+   *
+   * @return a textual representation of the object name.
+   */
+  public String toString()
+  {
+    return getClass().toString() +
+      "[domain = " + domain +
+      ",properties = " + properties +
+      ",propertyPattern = " + propertyPattern +
+      "]";
+  }
+
+  /**
+   * Unquotes the supplied string.  The quotation marks are removed as
+   * are the backslashes preceding the escaped characters ('"', '?',
+   * '*', '\n', '\\').  A one-to-one mapping exists between quoted and
+   * unquoted values.  As a result, a string <code>s</code> should be
+   * equal to <code>unquote(quote(s))</code>.
+   *
+   * @param q the quoted string to unquote.
+   * @return the unquoted string.
+   * @throws NullPointerException if <code>q</code> is <code>null</code>.
+   * @throws IllegalArgumentException if the string is not a valid
+   *                                  quoted string i.e. it is not 
+   *                                  surrounded by quotation marks
+   *                                  and/or characters are not properly
+   *                                  escaped.
+   */
+  public static String unquote(String q)
+  {
+    if (q.charAt(0) != '"')
+      throw new IllegalArgumentException("The string does " +
+					 "not start with a quote.");
+    if (q.charAt(q.length() - 1) != '"')
+      throw new IllegalArgumentException("The string does " +
+					 "not end with a quote.");
+    StringBuilder builder = new StringBuilder();
+    for (int a = 1; a < (q.length() - 1); ++a)
+      {
+	char n = q.charAt(a);
+	if (n == '\\')
+	  {
+	    n = q.charAt(++a);
+	    if (n != '"' && n != '?' && n != '*' &&
+		n != '\n' && n != '\\')
+	      throw new IllegalArgumentException("Illegal escaped character: "
+						 + n);
+	  }
+	builder.append(n);
+      }
+
+    return builder.toString();
+  }
+
+}
diff --git a/javax/management/QueryExp.java b/javax/management/QueryExp.java
new file mode 100644
index 000000000..124228c78
--- /dev/null
+++ b/javax/management/QueryExp.java
@@ -0,0 +1,87 @@
+/* QueryExp.java -- Represents a query expression.
+   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;
+
+import java.io.Serializable;
+
+/**
+ * Applies the type of relational constraints seen in the
+ * <code>where</code> clauses of databases to an
+ * {@link ObjectName}.  Instances of this class are usually
+ * returned by the static methods of the {@link Query} classes.
+ * If a custom implementation is required, it is better to
+ * extend the {@link QueryEval} class, rather than simply
+ * implementing this interface, in order to ensure that
+ * the {@link #setMBeanServer(MBeanServer)} method functions
+ * correctly.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface QueryExp
+  extends Serializable
+{
+
+  /**
+   * Applies the query to the specified management bean.
+   *
+   * @param name the name of the management bean.
+   * @return true if the query was applied successfully.
+   * @throws BadStringOperationException if an invalid string
+   *                                     operation is used by
+   *                                     the query.
+   * @throws BadBinaryOpValueExpException if an invalid expression
+   *                                      is used by the query.
+   * @throws BadAttributeValueExpException if an invalid attribute
+   *                                       is used by the query.
+   * @throws InvalidApplicationException if the query is applied
+   *                                     to the wrong type of bean.
+   */
+  boolean apply(ObjectName name)
+    throws BadStringOperationException, BadBinaryOpValueExpException,
+	   BadAttributeValueExpException, InvalidApplicationException;
+
+  /**
+   * Changes the {@link MBeanServer} on which this query is performed.
+   *
+   * @param server the new server to use.
+   */
+  void setMBeanServer(MBeanServer server);
+
+}
+
diff --git a/javax/management/ValueExp.java b/javax/management/ValueExp.java
new file mode 100644
index 000000000..503f23221
--- /dev/null
+++ b/javax/management/ValueExp.java
@@ -0,0 +1,86 @@
+/* ValueExp.java -- Represents values that can be passed to queries.
+   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;
+
+import java.io.Serializable;
+
+/**
+ * Represents values that may be passed as arguments to
+ * {@link QueryExp}s.  Strings, numbers and bean attributes
+ * are all valid argument types for query expressions, and
+ * so should be represented as implementations of this
+ * interface.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ */
+public interface ValueExp
+  extends Serializable
+{
+
+  /**
+   * Applies the value expression to the specified management bean.
+   *
+   * @param name the name of the management bean.
+   * @return the value expression.
+   * @throws BadStringOperationException if an invalid string
+   *                                     operation is used by
+   *                                     the value expression.
+   * @throws BadBinaryOpValueExpException if an invalid expression
+   *                                      is used by the value expression.
+   * @throws BadAttributeValueExpException if an invalid attribute
+   *                                       is used by the value expression.
+   * @throws InvalidApplicationException if the value expression is applied
+   *                                     to the wrong type of bean.
+   */
+  ValueExp apply(ObjectName name)
+    throws BadStringOperationException, BadBinaryOpValueExpException,
+	   BadAttributeValueExpException, InvalidApplicationException;
+
+  /**
+   * Changes the {@link MBeanServer} on which this query is performed.
+   *
+   * @param server the new server to use.
+   * @deprecated This method is superfluous, as the {@link ValueExp}
+   *             can access the server using
+   *             {@link QueryEval#getMBeanServer()}.
+   */
+  void setMBeanServer(MBeanServer server);
+
+}
+
diff --git a/javax/management/loading/ClassLoaderRepository.java b/javax/management/loading/ClassLoaderRepository.java
new file mode 100644
index 000000000..e2c8b7c5b
--- /dev/null
+++ b/javax/management/loading/ClassLoaderRepository.java
@@ -0,0 +1,139 @@
+/* ClassLoaderRepository.java -- Represents a collection of class loadersx.
+   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.loading;
+
+/**
+ * Implementations of this interface maintain a list of
+ * {@link ClassLoader}s for use by the management servers,
+ * allowing classes to be loaded by the first {@link ClassLoader}
+ * that will do so.  A class loader is added to the list
+ * whenever a {@link ClassLoader} instance is registered with
+ * the management server, and it does not implement the
+ * {@link PrivateClassLoader} interface.  They are removed when
+ * unregistered.  The first class loader in the list is always
+ * the one which was used to load the management server itself.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ * @since 1.5
+ * @see MBeanServerFactory
+ */
+public interface ClassLoaderRepository
+{
+
+  /**
+   * Attempts to load the given class using class loaders
+   * supplied by the list.  The {@link ClassLoader#loadClass(String)}
+   * method of each class loader is called.  If the method
+   * returns successfully, then the returned {@link Class} instance
+   * is returned.  If a {@link ClassNotFoundException} is thrown,
+   * then the next loader is tried.  Any other exception thrown
+   * by the method is passed back to the caller.  This method
+   * throws a {@link ClassNotFoundException} itself if all the
+   * class loaders listed prove fruitless.
+   *
+   * @param name the name of the class to load.
+   * @return the loaded class.
+   * @throws ClassNotFoundException if all the class loaders fail
+   *                                to load the class.
+   */
+  Class loadClass(String name)
+    throws ClassNotFoundException;
+
+  /**
+   * <p>
+   * Attempts to load the given class using class loaders
+   * supplied by the list, stopping when the specified
+   * loader is reached.  The {@link ClassLoader#loadClass(String)}
+   * method of each class loader is called.  If the method
+   * returns successfully, then the returned {@link Class} instance
+   * is returned.  If a {@link ClassNotFoundException} is thrown,
+   * then the next loader is tried.  Any other exception thrown
+   * by the method is passed back to the caller.  This method
+   * throws a {@link ClassNotFoundException} itself if all the
+   * class loaders listed prove fruitless.
+   * </p>
+   * <p>
+   * This method is usually used by the class loader specified
+   * by the <code>stop</code> argument to load classes using the
+   * loaders that appear before it in the list.  By stopping when
+   * the loader is reached, the deadlock that occurs when the loader
+   * is merely skipped is avoided.
+   * </p>
+   *
+   * @param stop the class loader at which to stop, or <code>null</code>
+   *             to obtain the same behaviour as {@link #loadClass(String)}.
+   * @param name the name of the class to load.
+   * @return the loaded class.
+   * @throws ClassNotFoundException if all the class loaders fail
+   *                                to load the class.
+   */
+  Class loadClassBefore(ClassLoader stop, String name)
+    throws ClassNotFoundException;
+
+  /**
+   * <p>
+   * Attempts to load the given class using class loaders
+   * supplied by the list, excluding the one specified.
+   * The {@link ClassLoader#loadClass(String)}
+   * method of each class loader is called.  If the method
+   * returns successfully, then the returned {@link Class} instance
+   * is returned.  If a {@link ClassNotFoundException} is thrown,
+   * then the next loader is tried.  Any other exception thrown
+   * by the method is passed back to the caller.  This method
+   * throws a {@link ClassNotFoundException} itself if all the
+   * class loaders listed prove fruitless.
+   * </p>
+   * <p>
+   * Note that this method may deadlock if called simultaneously
+   * by two class loaders in the list.
+   * {@link loadClassBefore(ClassLoader, String)} should be used
+   * in preference to this method to avoid this.
+   * </p>
+   *
+   * @param exclude the class loader to exclude, or <code>null</code>
+   *             to obtain the same behaviour as {@link #loadClass(String)}.
+   * @param name the name of the class to load.
+   * @return the loaded class.
+   * @throws ClassNotFoundException if all the class loaders fail
+   *                                to load the class.
+   */
+  Class loadClassWithout(ClassLoader exclude, String name)
+    throws ClassNotFoundException;
+
+}
+