# Class ClassManagerImpl

java.lang.Object
bsh.BshClassManager
bsh.classpath.ClassManagerImpl

public class ClassManagerImpl extends BshClassManager

    Manage all classloading in BeanShell.
    Allows classpath extension and class file reloading.

    This class holds the implementation of the BshClassManager so that it
    can be separated from the core package.

    This class currently relies on 1.2 for BshClassLoader and weak references.
    Is there a workaround for weak refs?  If so we could make this work
    with 1.1 by supplying our own classloader code...

    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
    created unless/until a class is generated, the classpath is modified,
    or a class is reloaded.

    Note: we may need some synchronization in here

    Note on jdk1.2 dependency:

    We are forced to use weak references here to accomodate all of the
    fleeting namespace listeners.  (NameSpaces must be informed if the class
    space changes so that they can un-cache names).  I had the interesting
    thought that a way around this would be to implement BeanShell's own
    garbage collector...  Then I came to my senses and said - screw it,
    class re-loading will require 1.2.

    ---------------------

    Classloading precedence:

    in-script evaluated class (scripted class)
    in-script added / modified classpath

    optionally, external classloader
    optionally, thread context classloader

    plain Class.forName()
    source class (.java file in classpath)

## Nested Class Summary

### Nested classes/interfaces inherited from class BshClassManager

`BshClassManager.Listener`

## Field Summary

### Fields inherited from class BshClassManager

`absoluteClassCache, absoluteNonClasses, definingClasses, definingClassesBaseNames, externalClassLoader, resolvedObjectMethods, resolvedStaticMethods`

## Constructor Summary

Constructors
Constructor
Description
`ClassManagerImpl()`
Used by BshClassManager singleton constructor

## Method Summary

Modifier and Type
Method
Description
`void`
`addClassPath(URL path)`
`void`
`addListener(BshClassManager.Listener l)`
`Class`
`classForName(String name)`
Load the specified class by name, taking into account added classpath and reloaded classes, etc.
`protected void`
`classLoaderChanged()`
Clear global class cache and notify namespaces to clear their class caches.
`Class`
`defineClass(String name, byte[] code)`
Get the BeanShell classloader.
`void`
`doSuperImport()`
Support for "import *;" Hide details in here as opposed to NameSpace.
`void`
`dump(PrintWriter i)`
`ClassLoader`
`getBaseLoader()`
`String`
`getClassNameByUnqName(String name)`
Return the name or null if none is found, Throw an ClassPathException containing detail if name is ambigous.
`BshClassPath`
`getClassPath()`
Get the full blown classpath.
`URL`
`getResource(String path)`
Get a resource URL using the BeanShell classpath
`InputStream`
`getResourceAsStream(String path)`
Get a resource stream using the BeanShell classpath
`protected boolean`
`hasSuperImport()`
A "super import" ("import *") operation has been performed.
`void`
`reloadAllClasses()`
Overlay the entire path with a new class loader.
`void`
`reloadClasses(String[] classNames)`
Reloading classes means creating a new classloader and using it whenever we are asked for classes in the appropriate space.
`void`
`reloadPackage(String pack)`
Reload all classes in the specified package: e.g.
`void`
`removeListener(BshClassManager.Listener l)`
`void`
`reset()`
Clear all classloading behavior and class caches and reset to initial state.
`void`
`setClassPath(URL[] cp)`
Set a new base classpath and create a new base classloader.

### Methods inherited from class BshClassManager

`cacheClassInfo, cacheResolvedMethod, classExists, clearCaches, cmUnavailable, createClassManager, definingClass, doneDefiningClass, getClassBeingDefined, getResolvedMethod, isClassBeingDefined, loadSourceClass, noClassDefFound, plainClassForName, setClassLoader`

### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### ClassManagerImpl

public ClassManagerImpl()
Used by BshClassManager singleton constructor

## Method Details

### classForName

public Class classForName(String name)
Description copied from class: `BshClassManager`
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.

Overrides:
  `classForName` in class `BshClassManager`
Returns:
  the class or null

### getResource

public URL getResource(String path)
Get a resource URL using the BeanShell classpath

Overrides:
  `getResource` in class `BshClassManager`
Parameters:
  `path` - should be an absolute path

### getResourceAsStream

public InputStream getResourceAsStream(String path)
Get a resource stream using the BeanShell classpath

Overrides:
  `getResourceAsStream` in class `BshClassManager`
Parameters:
  `path` - should be an absolute path

### addClassPath

public void addClassPath(URL path) throws IOException

Overrides:
  `addClassPath` in class `BshClassManager`
Throws:
  `IOException`

### reset

public void reset()
Clear all classloading behavior and class caches and reset to initial state.

Overrides:
  `reset` in class `BshClassManager`

### setClassPath

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

Overrides:
  `setClassPath` in class `BshClassManager`

### reloadAllClasses

public void reloadAllClasses() throws ClassPathException
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).

Overrides:
  `reloadAllClasses` in class `BshClassManager`
Throws:
  `ClassPathException`

### reloadClasses

public void reloadClasses(String[] classNames) throws ClassPathException
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

Overrides:
  `reloadClasses` in class `BshClassManager`
Throws:
  `ClassPathException`

### reloadPackage

public void reloadPackage(String pack) throws ClassPathException
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.

Overrides:
  `reloadPackage` in class `BshClassManager`
Throws:
  `ClassPathException`

### getClassPath

public BshClassPath getClassPath() throws ClassPathException
Get the full blown classpath.

Throws:
  `ClassPathException`

### doSuperImport

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

Overrides:
  `doSuperImport` in class `BshClassManager`
Throws:
  `UtilEvalError`

### hasSuperImport

protected boolean hasSuperImport()
Description copied from class: `BshClassManager`
A "super import" ("import *") operation has been performed.

Overrides:
  `hasSuperImport` in class `BshClassManager`

### getClassNameByUnqName

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

Overrides:
  `getClassNameByUnqName` in class `BshClassManager`
Throws:
  `ClassPathException`

### addListener

public void addListener(BshClassManager.Listener l)

Overrides:
  `addListener` in class `BshClassManager`

### removeListener

public void removeListener(BshClassManager.Listener l)

Overrides:
  `removeListener` in class `BshClassManager`

### getBaseLoader

public ClassLoader getBaseLoader()

### defineClass

public Class defineClass(String name, byte[] code)
Get the BeanShell classloader. public ClassLoader getClassLoader() { }

Overrides:
  `defineClass` in class `BshClassManager`

### classLoaderChanged

protected void classLoaderChanged()
Clear global class cache and notify namespaces to clear their class caches. The listener list is implemented with weak references so that we will not keep every namespace in existence forever.

Overrides:
  `classLoaderChanged` in class `BshClassManager`

### dump

public void dump(PrintWriter i)

Overrides:
  `dump` in class `BshClassManager`