public MLet() 
{
     
         primitiveClasses.put(Boolean.TYPE.toString(), Boolean.class);
         primitiveClasses.put(Character.TYPE.toString(), Character.class);
         primitiveClasses.put(Byte.TYPE.toString(), Byte.class);
         primitiveClasses.put(Short.TYPE.toString(), Short.class);
         primitiveClasses.put(Integer.TYPE.toString(), Integer.class);
         primitiveClasses.put(Long.TYPE.toString(), Long.class);
         primitiveClasses.put(Float.TYPE.toString(), Float.class);
         primitiveClasses.put(Double.TYPE.toString(), Double.class);
         this(new URL[0]);
}

Constructs a new MLet using the default delegation parent ClassLoader.

 public MLet(URL[] urls) 
{
         this(urls, true);
}

Constructs a new MLet for the specified URLs using the default delegation parent ClassLoader. The URLs will be searched in the order specified for classes and resources after first searching in the parent class loader.

Parameters:

urls - The URLs from which to load classes and resources.

 public MLet(URL[] urls,
    ClassLoader parent) 
{
         this(urls, parent, true);
}

Constructs a new MLet for the given URLs. The URLs will be searched in the order specified for classes and resources after first searching in the specified parent class loader. The parent argument will be used as the parent class loader for delegation.

Parameters:

urls - The URLs from which to load classes and resources.

parent - The parent class loader for delegation.

 public MLet(URL[] urls,
    boolean delegateToCLR) 
{
         super(urls);
         init(delegateToCLR);
}

Constructs a new MLet for the specified URLs using the default delegation parent ClassLoader. The URLs will be searched in the order specified for classes and resources after first searching in the parent class loader.

Parameters:

urls - The URLs from which to load classes and resources.

delegateToCLR - True if, when a class is not found in either the parent ClassLoader or the URLs, the MLet should delegate to its containing MBeanServer's ClassLoaderRepository .

 public MLet(URL[] urls,
    ClassLoader parent,
    URLStreamHandlerFactory factory) 
{
         this(urls, parent, factory, true);
}

Constructs a new MLet for the specified URLs, parent class loader, and URLStreamHandlerFactory. The parent argument will be used as the parent class loader for delegation. The factory argument will be used as the stream handler factory to obtain protocol handlers when creating new URLs.

Parameters:

urls - The URLs from which to load classes and resources.

parent - The parent class loader for delegation.

factory - The URLStreamHandlerFactory to use when creating URLs.

 public MLet(URL[] urls,
    ClassLoader parent,
    boolean delegateToCLR) 
{
         super(urls, parent);
         init(delegateToCLR);
}

Constructs a new MLet for the given URLs. The URLs will be searched in the order specified for classes and resources after first searching in the specified parent class loader. The parent argument will be used as the parent class loader for delegation.

Parameters:

urls - The URLs from which to load classes and resources.

parent - The parent class loader for delegation.

delegateToCLR - True if, when a class is not found in either the parent ClassLoader or the URLs, the MLet should delegate to its containing MBeanServer's ClassLoaderRepository .

 public MLet(URL[] urls,
    ClassLoader parent,
    URLStreamHandlerFactory factory,
    boolean delegateToCLR) 
{
         super(urls, parent, factory);
         init(delegateToCLR);
}

Constructs a new MLet for the specified URLs, parent class loader, and URLStreamHandlerFactory. The parent argument will be used as the parent class loader for delegation. The factory argument will be used as the stream handler factory to obtain protocol handlers when creating new URLs.

Parameters:

urls - The URLs from which to load classes and resources.

parent - The parent class loader for delegation.

factory - The URLStreamHandlerFactory to use when creating URLs.

delegateToCLR - True if, when a class is not found in either the parent ClassLoader or the URLs, the MLet should delegate to its containing MBeanServer's ClassLoaderRepository .

 public  void addURL(URL url) 
{
         if (!Arrays.asList(getURLs()).contains(url))
             super.addURL(url);
}

Appends the specified URL to the list of URLs to search for classes and resources.

 public  void addURL(String url) throws ServiceNotFoundException 
{
         try {
             URL ur = new URL(url);
             if (!Arrays.asList(getURLs()).contains(ur))
                 super.addURL(ur);
         } catch (MalformedURLException e) {
             if (MLET_LOGGER.isLoggable(Level.FINEST)) {
                 MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
                         "addUrl", "Malformed URL: " + url, e);
             }
             throw new
                 ServiceNotFoundException("The specified URL is malformed");
         }
}

Appends the specified URL to the list of URLs to search for classes and resources.

 protected URL check(String version,
    URL codebase,
    String jarfile,
    MLetContent mlet) throws Exception 
{
         return codebase;
}

This method is to be overridden when extending this service to support caching and versioning. It is called from getMBeansFromURL when the version, codebase, and jarfile have been extracted from the MLet file, and can be used to verify that it is all right to load the given MBean, or to replace the given URL with a different one.

The default implementation of this method returns codebase unchanged.

 protected Class findClass(String name) throws ClassNotFoundException 
{
         /* currentClr is context sensitive - used to avoid recursion
            in the class loader repository.  (This is no longer
            necessary with the new CLR semantics but is kept for
            compatibility with code that might have called the
            two-parameter loadClass explicitly.)  */
         return findClass(name, currentClr);
}

This is the main method for class loaders that is being redefined.

 Class findClass(String name,
    ClassLoaderRepository clr) throws ClassNotFoundException 
{
         Class< ? > c = null;
         MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), "findClass", name);
         // Try looking in the JAR:
         try {
             c = super.findClass(name);
             if (MLET_LOGGER.isLoggable(Level.FINER)) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
                         "findClass",
                         "Class " + name + " loaded through MLet classloader");
             }
         } catch (ClassNotFoundException e) {
             // Drop through
             if (MLET_LOGGER.isLoggable(Level.FINEST)) {
                 MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
                         "findClass",
                         "Class " + name + " not found locally");
             }
         }
         // if we are not called from the ClassLoaderRepository
         if (c == null && delegateToCLR && clr != null) {
             // Try the classloader repository:
             //
             try {
                 if (MLET_LOGGER.isLoggable(Level.FINEST)) {
                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
                             "findClass",
                             "Class " + name + " : looking in CLR");
                 }
                 c = clr.loadClassBefore(this, name);
                 // The loadClassBefore method never returns null.
                 // If the class is not found we get an exception.
                 if (MLET_LOGGER.isLoggable(Level.FINER)) {
                     MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
                             "findClass",
                             "Class " + name + " loaded through " +
                             "the default classloader repository");
                 }
             } catch (ClassNotFoundException e) {
                 // Drop through
                 if (MLET_LOGGER.isLoggable(Level.FINEST)) {
                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
                             "findClass",
                             "Class " + name + " not found in CLR");
                 }
             }
         }
         if (c == null) {
             MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
                     "findClass", "Failed to load class " + name);
             throw new ClassNotFoundException(name);
         }
         return c;
}

Called by MLet#findClass(java.lang.String) .

 protected String findLibrary(String libname) 
{
         String abs_path;
         String mth = "findLibrary";
         // Get the platform-specific string representing a native library.
         //
         String nativelibname = System.mapLibraryName(libname);
         //
         // See if the native library is accessible as a resource through the JAR file.
         //
         if (MLET_LOGGER.isLoggable(Level.FINER)) {
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                     "Search " + libname + " in all JAR files");
         }
         // First try to locate the library in the JAR file using only
         // the native library name.  e.g. if user requested a load
         // for "foo" on Solaris SPARC 5.7 we try to load "libfoo.so"
         // from the JAR file.
         //
         if (MLET_LOGGER.isLoggable(Level.FINER)) {
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                     "loadLibraryAsResource(" + nativelibname + ")");
         }
         abs_path = loadLibraryAsResource(nativelibname);
         if (abs_path != null) {
             if (MLET_LOGGER.isLoggable(Level.FINER)) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         nativelibname + " loaded, absolute path = " + abs_path);
             }
             return abs_path;
         }
         // Next try to locate it using the native library name and
         // the architecture-specific path name.  e.g. if user
         // requested a load for "foo" on Solaris SPARC 5.7 we try to
         // load "SunOS/sparc/5.7/lib/libfoo.so" from the JAR file.
         //
         nativelibname = removeSpace(System.getProperty("os.name")) + File.separator +
             removeSpace(System.getProperty("os.arch")) + File.separator +
             removeSpace(System.getProperty("os.version")) + File.separator +
             "lib" + File.separator + nativelibname;
         if (MLET_LOGGER.isLoggable(Level.FINER)) {
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                     "loadLibraryAsResource(" + nativelibname + ")");
         }
         abs_path = loadLibraryAsResource(nativelibname);
         if (abs_path != null) {
             if (MLET_LOGGER.isLoggable(Level.FINER)) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         nativelibname + " loaded, absolute path = " + abs_path);
             }
             return abs_path;
         }
         //
         // All paths exhausted, library not found in JAR file.
         //
         if (MLET_LOGGER.isLoggable(Level.FINER)) {
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                     libname + " not found in any JAR file");
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                     "Search " + libname + " along the path " +
                     "specified as the java.library.path property");
         }
         // Let the VM search the library along the path
         // specified as the java.library.path property.
         //
         return null;
}

Returns the absolute path name of a native library. The VM invokes this method to locate the native libraries that belong to classes loaded with this class loader. Libraries are searched in the JAR files using first just the native library name and if not found the native library name together with the architecture-specific path name (OSName/OSArch/OSVersion/lib/nativelibname), i.e.

the library stat on Solaris SPARC 5.7 will be searched in the JAR file as:

1. libstat.so
2. SunOS/sparc/5.7/lib/libstat.so
the library stat on Windows NT 4.0 will be searched in the JAR file as:
1. stat.dll
2. WindowsNT/x86/4.0/lib/stat.dll

More specifically, let {@code nativelibname} be the result of System.mapLibraryName {@code (libname)}. Then the following names are searched in the JAR files, in order:
{@code nativelibname}
{@code ///lib/}{@code nativelibname}
where {@code } means {@code System.getProperty(X)} with any spaces in the result removed, and {@code /} stands for the file separator character (File#separator ).

If this method returns null, i.e. the libraries were not found in any of the JAR files loaded with this class loader, the VM searches the library along the path specified as the java.library.path property.

 public synchronized String getLibraryDirectory() 
{
         return libraryDirectory;
}

Gets the current directory used by the library loader for storing native libraries before they are loaded into memory.

 public Set getMBeansFromURL(URL url) throws ServiceNotFoundException 
{
         if (url == null) {
             throw new ServiceNotFoundException("The specified URL is null");
         }
         return getMBeansFromURL(url.toString());
}

Loads a text file containing MLET tags that define the MBeans to be added to the MBean server. The location of the text file is specified by a URL. The MBeans specified in the MLET file will be instantiated and registered in the MBean server.

 public Set getMBeansFromURL(String url) throws ServiceNotFoundException 
{
         String mth = "getMBeansFromURL";
         if (server == null) {
             throw new IllegalStateException("This MLet MBean is not " +
                                             "registered with an MBeanServer.");
         }
         // Parse arguments
         if (url == null) {
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
                     mth, "URL is null");
             throw new ServiceNotFoundException("The specified URL is null");
         } else {
             url = url.replace(File.separatorChar,'/");
         }
         if (MLET_LOGGER.isLoggable(Level.FINER)) {
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
                     mth, "< URL = " + url + " >");
         }
         // Parse URL
         try {
             MLetParser parser = new MLetParser();
             mletList = parser.parseURL(url);
         } catch (Exception e) {
             final String msg =
                 "Problems while parsing URL [" + url +
                 "], got exception [" + e.toString() + "]";
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
             throw EnvHelp.initCause(new ServiceNotFoundException(msg), e);
         }
         // Check that the list of MLets is not empty
         if (mletList.size() == 0) {
             final String msg =
                 "File " + url + " not found or MLET tag not defined in file";
             MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
             throw new ServiceNotFoundException(msg);
         }
         // Walk through the list of MLets
         Set< Object > mbeans = new HashSet< Object >();
         for (MLetContent elmt : mletList) {
             // Initialize local variables
             String code = elmt.getCode();
             if (code != null) {
                 if (code.endsWith(".class")) {
                     code = code.substring(0, code.length() - 6);
                 }
             }
             String name = elmt.getName();
             URL codebase = elmt.getCodeBase();
             String version = elmt.getVersion();
             String serName = elmt.getSerializedObject();
             String jarFiles = elmt.getJarFiles();
             URL documentBase = elmt.getDocumentBase();
             // Display debug information
             if (MLET_LOGGER.isLoggable(Level.FINER)) {
                 final StringBuilder strb = new StringBuilder()
                 .append("\n\tMLET TAG     = ").append(elmt.getAttributes())
                 .append("\n\tCODEBASE     = ").append(codebase)
                 .append("\n\tARCHIVE      = ").append(jarFiles)
                 .append("\n\tCODE         = ").append(code)
                 .append("\n\tOBJECT       = ").append(serName)
                 .append("\n\tNAME         = ").append(name)
                 .append("\n\tVERSION      = ").append(version)
                 .append("\n\tDOCUMENT URL = ").append(documentBase);
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(),
                         mth, strb.toString());
             }
             // Load classes from JAR files
             StringTokenizer st = new StringTokenizer(jarFiles, ",", false);
             while (st.hasMoreTokens()) {
                 String tok = st.nextToken().trim();
                 if (MLET_LOGGER.isLoggable(Level.FINER)) {
                     MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                             "Load archive for codebase < " + codebase +
                             " >, file < " + tok + " >");
                 }
                 // Check which is the codebase to be used for loading the jar file.
                 // If we are using the base MLet implementation then it will be
                 // always the remote server but if the service has been extended in
                 // order to support caching and versioning then this method will
                 // return the appropriate one.
                 //
                 try {
                     codebase = check(version, codebase, tok, elmt);
                 } catch (Exception ex) {
                     MLET_LOGGER.logp(Level.FINEST, MLet.class.getName(),
                             mth, "Got unexpected exception", ex);
                     mbeans.add(ex);
                     continue;
                 }
                 // Appends the specified JAR file URL to the list of
                 // URLs to search for classes and resources.
                 try {
                     if (!Arrays.asList(getURLs())
                         .contains(new URL(codebase.toString() + tok))) {
                         addURL(codebase + tok);
                     }
                 } catch (MalformedURLException me) {
                     // OK : Ignore jar file if its name provokes the
                     // URL to be an invalid one.
                 }
             }
             // Instantiate the class specified in the
             // CODE or OBJECT section of the MLet tag
             //
             Object o;
             ObjectInstance objInst;
             if (code != null && serName != null) {
                 final String msg =
                     "CODE and OBJECT parameters cannot be specified at the " +
                     "same time in tag MLET";
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
                 mbeans.add(new Error(msg));
                 continue;
             }
             if (code == null && serName == null) {
                 final String msg =
                     "Either CODE or OBJECT parameter must be specified in " +
                     "tag MLET";
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth, msg);
                 mbeans.add(new Error(msg));
                 continue;
             }
             try {
                 if (code != null) {
                     List< String > signat = elmt.getParameterTypes();
                     List< String > stringPars = elmt.getParameterValues();
                     List< Object > objectPars = new ArrayList< Object >();
                     for (int i = 0; i <  signat.size(); i++) {
                         objectPars.add(constructParameter(stringPars.get(i),
                                                           signat.get(i)));
                     }
                     if (signat.isEmpty()) {
                         if (name == null) {
                             objInst = server.createMBean(code, null,
                                                          mletObjectName);
                         } else {
                             objInst = server.createMBean(code,
                                                          new ObjectName(name),
                                                          mletObjectName);
                         }
                     } else {
                         Object[] parms = objectPars.toArray();
                         String[] signature = new String[signat.size()];
                         signat.toArray(signature);
                         if (MLET_LOGGER.isLoggable(Level.FINEST)) {
                             final StringBuilder strb = new StringBuilder();
                             for (int i = 0; i <  signature.length; i++) {
                                 strb.append("\n\tSignature     = ")
                                 .append(signature[i])
                                 .append("\t\nParams        = ")
                                 .append(parms[i]);
                             }
                             MLET_LOGGER.logp(Level.FINEST,
                                     MLet.class.getName(),
                                     mth, strb.toString());
                         }
                         if (name == null) {
                             objInst =
                                 server.createMBean(code, null, mletObjectName,
                                                    parms, signature);
                         } else {
                             objInst =
                                 server.createMBean(code, new ObjectName(name),
                                                    mletObjectName, parms,
                                                    signature);
                         }
                     }
                 } else {
                     o = loadSerializedObject(codebase,serName);
                     if (name == null) {
                         server.registerMBean(o, null);
                     } else {
                         server.registerMBean(o,  new ObjectName(name));
                     }
                     objInst = new ObjectInstance(name, o.getClass().getName());
                 }
             } catch (ReflectionException  ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "ReflectionException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (InstanceAlreadyExistsException  ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "InstanceAlreadyExistsException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (MBeanRegistrationException ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "MBeanRegistrationException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (MBeanException  ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "MBeanException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (NotCompliantMBeanException  ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "NotCompliantMBeanException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (InstanceNotFoundException   ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "InstanceNotFoundException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (IOException ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "IOException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (SecurityException ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "SecurityException", ex);
                 mbeans.add(ex);
                 continue;
             } catch (Exception ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "Exception", ex);
                 mbeans.add(ex);
                 continue;
             } catch (Error ex) {
                 MLET_LOGGER.logp(Level.FINER, MLet.class.getName(), mth,
                         "Error", ex);
                 mbeans.add(ex);
                 continue;
             }
             mbeans.add(objInst);
         }
         return mbeans;
}

Loads a text file containing MLET tags that define the MBeans to be added to the MBean server. The location of the text file is specified by a URL. The MBeans specified in the MLET file will be instantiated and registered in the MBean server.

 public URL[] getURLs() 
{
         return super.getURLs();
}

Returns the search path of URLs for loading classes and resources. This includes the original list of URLs specified to the constructor, along with any URLs subsequently appended by the addURL() method.

 public synchronized Class loadClass(String name,
    ClassLoaderRepository clr) throws ClassNotFoundException 
{
         final ClassLoaderRepository before=currentClr;
         try {
             currentClr = clr;
             return loadClass(name);
         } finally {
             currentClr = before;
         }
}

Load a class, using the given ClassLoaderRepository if the class is not found in this MLet's URLs. The given ClassLoaderRepository can be null, in which case a ClassNotFoundException occurs immediately if the class is not found in this MLet's URLs.

 public  void postDeregister() 
{

}

Allows the m-let to perform any operations needed after having been unregistered in the MBean server.

 public  void postRegister(Boolean registrationDone) 
{

}

Allows the m-let to perform any operations needed after having been registered in the MBean server or after the registration has failed.

 public  void preDeregister() throws Exception 
{

}

Allows the m-let to perform any operations it needs before being unregistered by the MBean server.

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
         // Initialize local pointer to the MBean server
         setMBeanServer(server);
         // If no name is specified return a default name for the MLet
         if (name == null) {
             name = new ObjectName(server.getDefaultDomain() + ":" + ServiceName.MLET);
         }
        this.mletObjectName = name;
        return this.mletObjectName;
}

Allows the m-let to perform any operations it needs before being registered in the MBean server. If the ObjectName is null, the m-let provides a default name for its registration <defaultDomain>:type=MLet

 public  void readExternal(ObjectInput in) throws UnsupportedOperationException, ClassNotFoundException, IOException 
{
         throw new UnsupportedOperationException("MLet.readExternal");
}

Restore this MLet's contents from the given ObjectInput . Not all implementations support this method. Those that do not throw UnsupportedOperationException . A subclass may override this method to support it or to change the format of the read data.

The format of the read data is not specified, but if an implementation supports #readExternal it must also support #writeExternal in such a way that what is written by the latter can be read by the former.

 public synchronized  void setLibraryDirectory(String libdir) 
{
         libraryDirectory = libdir;
}

Sets the directory used by the library loader for storing native libraries before they are loaded into memory.

 public  void writeExternal(ObjectOutput out) throws UnsupportedOperationException, IOException 
{
         throw new UnsupportedOperationException("MLet.writeExternal");
}

Save this MLet's contents to the given ObjectOutput . Not all implementations support this method. Those that do not throw UnsupportedOperationException . A subclass may override this method to support it or to change the format of the written data.

The format of the written data is not specified, but if an implementation supports #writeExternal it must also support #readExternal in such a way that what is written by the former can be read by the latter.