Module jEdit
Package org.gjt.sp.jedit.bsh

Class BshClassManager

java.lang.Object
org.gjt.sp.jedit.bsh.BshClassManager
Direct Known Subclasses:
ClassManagerImpl
public class BshClassManager extends Object
BshClassManager manages all classloading in BeanShell. It also supports a dynamically loaded extension (bsh.classpath package) which allows classpath extension and class file reloading. Currently the extension relies on 1.2 for BshClassLoader and weak references. See http://www.beanshell.org/manual/classloading.html for details on the bsh classloader architecture.

Bsh has a multi-tiered class loading architecture. No class loader is used unless/until the classpath is modified or a class is reloaded.

  • Field Details

    • externalClassLoader

      protected ClassLoader externalClassLoader
      An external classloader supplied by the setClassLoader() command.

    • absoluteClassCache

      protected transient Hashtable absoluteClassCache
      Global cache for things we know are classes. Note: these should probably be re-implemented with Soft references. (as opposed to strong or Weak)

    • absoluteNonClasses

      protected transient Hashtable absoluteNonClasses
      Global cache for things we know are *not* classes. Note: these should probably be re-implemented with Soft references. (as opposed to strong or Weak)

    • resolvedObjectMethods

      protected transient Hashtable resolvedObjectMethods
      Caches for resolved object and static methods. We keep these maps separate to support fast lookup in the general case where the method may be either.

    • resolvedStaticMethods

      protected transient Hashtable resolvedStaticMethods

    • definingClasses

      protected transient Hashtable definingClasses

    • definingClassesBaseNames

      protected transient Hashtable definingClassesBaseNames

  • Constructor Details

    • BshClassManager

      public BshClassManager()

  • Method Details

    • createClassManager

      public static BshClassManager createClassManager(Interpreter interpreter)
      Create a new instance of the class manager. Class manager instnaces are now associated with the interpreter.
      See Also:

    • classExists

      public boolean classExists(String name)

    • classForName

      public Class classForName(String name)
      Load the specified class by name, taking into account added classpath and reloaded classes, etc. Note: Again, this is just a trivial implementation. See bsh.classpath.ClassManagerImpl for the fully functional class management package.
      Returns:
      the class or null

    • loadSourceClass

      protected Class loadSourceClass(String name)

    • plainClassForName

      public Class plainClassForName(String name) throws ClassNotFoundException
      Perform a plain Class.forName() or call the externally provided classloader. If a BshClassManager implementation is loaded the call will be delegated to it, to allow for additional hooks.

      This simply wraps that bottom level class lookup call and provides a central point for monitoring and handling certain Java version dependent bugs, etc.

      Returns:
      the class
      Throws:
      ClassNotFoundException
      See Also:

    • getResource

      public URL getResource(String path)
      Get a resource URL using the BeanShell classpath
      Parameters:
      path - should be an absolute path

    • getResourceAsStream

      public InputStream getResourceAsStream(String path)
      Get a resource stream using the BeanShell classpath
      Parameters:
      path - should be an absolute path

    • cacheClassInfo

      public void cacheClassInfo(String name, Class value)
      Cache info about whether name is a class or not.
      Parameters:
      value - if value is non-null, cache the class if value is null, set the flag that it is *not* a class to speed later resolution

    • cacheResolvedMethod

      public void cacheResolvedMethod(Class clas, Class[] types, Method method)
      Cache a resolved (possibly overloaded) method based on the argument types used to invoke it, subject to classloader change. Static and Object methods are cached separately to support fast lookup in the general case where either will do.

    • getResolvedMethod

      protected Method getResolvedMethod(Class clas, String methodName, Class[] types, boolean onlyStatic)
      Return a previously cached resolved method.
      Parameters:
      onlyStatic - specifies that only a static method may be returned.
      Returns:
      the Method or null

    • clearCaches

      protected void clearCaches()
      Clear the caches in BshClassManager

    • setClassLoader

      public void setClassLoader(ClassLoader externalCL)
      Set an external class loader. BeanShell will use this at the same point it would otherwise use the plain Class.forName(). i.e. if no explicit classpath management is done from the script (addClassPath(), setClassPath(), reloadClasses()) then BeanShell will only use the supplied classloader. If additional classpath management is done then BeanShell will perform that in addition to the supplied external classloader. However BeanShell is not currently able to reload classes supplied through the external classloader.

    • addClassPath

      public void addClassPath(URL path) throws IOException
      Throws:
      IOException

    • reset

      public void reset()
      Clear all loaders and start over. No class loading.

    • setClassPath

      public void setClassPath(URL[] cp) throws UtilEvalError
      Set a new base classpath and create a new base classloader. This means all types change.
      Throws:
      UtilEvalError

    • reloadAllClasses

      public void reloadAllClasses() throws UtilEvalError
      Overlay the entire path with a new class loader. Set the base path to the user path + base path. No point in including the boot class path (can't reload thos).
      Throws:
      UtilEvalError

    • reloadClasses

      public void reloadClasses(String[] classNames) throws UtilEvalError
      Reloading classes means creating a new classloader and using it whenever we are asked for classes in the appropriate space. For this we use a DiscreteFilesClassLoader
      Throws:
      UtilEvalError

    • reloadPackage

      public void reloadPackage(String pack) throws UtilEvalError
      Reload all classes in the specified package: e.g. "com.sun.tools" The special package name "<unpackaged>" can be used to refer to unpackaged classes.
      Throws:
      UtilEvalError

    • doSuperImport

      protected void doSuperImport() throws UtilEvalError
      Support for "import *;" Hide details in here as opposed to NameSpace.
      Throws:
      UtilEvalError

    • hasSuperImport

      protected boolean hasSuperImport()
      A "super import" ("import *") operation has been performed.

    • getClassNameByUnqName

      protected String getClassNameByUnqName(String name) throws UtilEvalError
      Return the name or null if none is found, Throw an ClassPathException containing detail if name is ambigous.
      Throws:
      UtilEvalError

    • addListener

      public void addListener(BshClassManager.Listener l)

    • removeListener

      public void removeListener(BshClassManager.Listener l)

    • dump

      public void dump(PrintWriter pw)

    • definingClass

      protected void definingClass(String className)
      Flag the class name as being in the process of being defined. The class manager will not attempt to load it.

    • isClassBeingDefined

      protected boolean isClassBeingDefined(String className)

    • getClassBeingDefined

      protected String getClassBeingDefined(String className)
      This method is a temporary workaround used with definingClass. It is to be removed at some point.

    • doneDefiningClass

      protected void doneDefiningClass(String className)
      Indicate that the specified class name has been defined and may be loaded normally.

    • defineClass

      public Class defineClass(String name, byte[] code)

    • classLoaderChanged

      protected void classLoaderChanged()

    • noClassDefFound

      protected static Error noClassDefFound(String className, Error e)
      Annotate the NoClassDefFoundError with some info about the class we were trying to load.

    • cmUnavailable

      protected static UtilEvalError cmUnavailable()