ClassPool (XApi - Dev uber jar 0.5 API)

java.lang.Object
- xapi.bytecode.ClassPool

```
public class ClassPool
extends Object
```

Field Summary

Fields
Modifier and Type	Field and Description
`boolean`	`childFirstLookup` Determines the search order.
`protected Hashtable<String,CtClass>`	`classes`
`static boolean`	`doPruning` Turning the automatic pruning on/off.
`protected ClassPool`	`parent`
`static boolean`	`releaseUnmodifiedClassFile` If true, unmodified and not-recently-used class files are periodically released for saving memory.
`protected xapi.bytecode.ClassPoolTail`	`source`

Constructor Summary

Constructors
Constructor and Description
`ClassPool()` Creates a root class pool.
`ClassPool(boolean useDefaultPath)` Creates a root class pool.
`ClassPool(ClassPool parent)` Creates a class pool.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ClassPath`	`appendClassPath(ClassPath cp)` Appends a `ClassPath` object to the end of the search path.
`ClassPath`	`appendClassPath(String pathname)` Appends a directory or a jar (or zip) file to the end of the search path.
`void`	`appendPathList(String pathlist)` Appends directories and jar files for search.
`ClassPath`	`appendSystemPath()` Appends the system search path to the end of the search path.
`protected void`	`cacheCtClass(String classname, CtClass c, boolean dynamic)` Provides a hook so that subclasses can do their own caching of classes.
`void`	`clearImportedPackages()` Clear all the package names recorded by `importPackage()`.
`protected CtClass`	`createCtClass(String classname, boolean useCache)` Creates a CtClass object representing the specified class.
`URL`	`find(String classname)` Searches the class path to obtain the URL of the class file specified by classname.
`CtClass`	`get(String classname)` Reads a class file from the source and returns a reference to the `CtClass` object representing that class file.
`CtClass[]`	`get(String[] classnames)` Reads class files from the source and returns an array of `CtClass` objects representing those class files.
`protected CtClass`	`get0(String classname, boolean useCache)`
`CtClass`	`getAndRename(String orgName, String newName)` Reads a class file and constructs a `CtClass` object with a new name.
`protected CtClass`	`getCached(String classname)` Provide a hook so that subclasses can do their own caching of classes.
`ClassLoader`	`getClassLoader()` Get the classloader for `toClass()`, `getAnnotations()` in `CtClass`, etc.
`CtClass`	`getCtClass(String classname)` Returns a `CtClass` object with the given name.
`static ClassPool`	`getDefault()` Returns the default class pool.
`Iterator<String>`	`getImportedPackages()` Returns all the package names recorded by `importPackage()`.
`CtClass`	`getOrNull(String classname)` Reads a class file from the source and returns a reference to the `CtClass` object representing that class file.
`void`	`importPackage(String packageName)` Record a package name so that the Javassist compiler searches the package to resolve a class name.
`ClassPath`	`insertClassPath(ClassPath cp)` Insert a `ClassPath` object at the head of the search path.
`ClassPath`	`insertClassPath(String pathname)` Inserts a directory or a jar (or zip) file at the head of the search path.
`CtClass`	`makeClass(InputStream classfile)` Creates a new class (or interface) from the given class file.
`CtClass`	`makeClass(InputStream classfile, boolean ifNotFrozen)` Creates a new class (or interface) from the given class file.
`CtClass`	`makeClass(String classname)` Creates a new public class.
`CtClass`	`makeClass(String classname, CtClass superclass)` Creates a new public class.
`CtClass`	`makeClassIfNew(InputStream classfile)` Creates a new class (or interface) from the given class file.
`CtClass`	`makeInterface(String name)` Creates a new public interface.
`CtClass`	`makeInterface(String name, CtClass superclass)` Creates a new public interface.
`void`	`recordInvalidClassName(String name)` Records a name that never exists.
`protected CtClass`	`removeCached(String classname)` Provide a hook so that subclasses can do their own caching of classes.
`void`	`removeClassPath(ClassPath cp)` Detatches the `ClassPath` object from the search path.
`String`	`toString()` Returns the class search path.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - childFirstLookup
```
public boolean childFirstLookup
```
    Determines the search order.
    If this field is true, get() first searches the class path associated to this ClassPool and then the class path associated with the parent ClassPool. Otherwise, the class path associated with the parent is searched first.
    The default value is false.
  - doPruning
```
public static boolean doPruning
```
    Turning the automatic pruning on/off.
    If this field is true, CtClass objects are automatically pruned by default when toBytecode() etc. are called. The automatic pruning can be turned on/off individually for each CtClass object.
    The initial value is false.
    
    See Also:
    
    CtClass.prune(), CtClass.stopPruning(boolean), CtClass.detach()
  - releaseUnmodifiedClassFile
```
public static boolean releaseUnmodifiedClassFile
```
    If true, unmodified and not-recently-used class files are periodically released for saving memory.
    The initial value is true.
  - source
```
protected xapi.bytecode.ClassPoolTail source
```
  - parent
```
protected ClassPool parent
```
  - classes
```
protected Hashtable<String,CtClass> classes
```
- Constructor Detail
  - ClassPool
```
public ClassPool()
```
    Creates a root class pool. No parent class pool is specified.
  - ClassPool
```
public ClassPool(boolean useDefaultPath)
```
    Creates a root class pool. If useDefaultPath is true, appendSystemPath() is called. Otherwise, this constructor is equivalent to the constructor taking no parameter.
    
    Parameters:
    
    useDefaultPath - true if the system search path is appended.
  - ClassPool
```
public ClassPool(ClassPool parent)
```
    Creates a class pool.
    
    Parameters:
    
    parent - the parent of this class pool. If this is a root class pool, this parameter must be null.
    
    See Also:
    
    javassist.ClassPool#getDefault()
- Method Detail
  - getDefault
```
public static ClassPool getDefault()
```
    Returns the default class pool. The returned object is always identical since this method is a singleton factory.
    The default class pool searches the system search path, which usually includes the platform library, extension libraries, and the search path specified by the -classpath option or the CLASSPATH environment variable.
    When this method is called for the first time, the default class pool is created with the following code snippet:
    If the default class pool cannot find any class files, try ClassClassPath and LoaderClassPath.
    See Also:
    
    ClassClassPath, LoaderClassPath
  - getCached
```
protected CtClass getCached(String classname)
```
    Provide a hook so that subclasses can do their own caching of classes.
    
    See Also:
    
    cacheCtClass(String,CtClass,boolean), removeCached(String)
  - cacheCtClass
```
protected void cacheCtClass(String classname,
                            CtClass c,
                            boolean dynamic)
```
    Provides a hook so that subclasses can do their own caching of classes.
    
    See Also:
    
    getCached(String), #removeCached(String,CtClass)
  - removeCached
```
protected CtClass removeCached(String classname)
```
    Provide a hook so that subclasses can do their own caching of classes.
    
    See Also:
    
    getCached(String), cacheCtClass(String,CtClass,boolean)
  - toString
```
public String toString()
```
    Returns the class search path.
    
    Overrides:
    
    toString in class Object
  - importPackage
```
public void importPackage(String packageName)
```
    Record a package name so that the Javassist compiler searches the package to resolve a class name. Don't record the java.lang package, which has been implicitly recorded by default.
    Note that get() in ClassPool does not search the recorded package. Only the compiler searches it.
    
    Parameters:
    
    packageName - the package name. It must not include the last '.' (dot). For example, "java.util" is valid but "java.util." is wrong.
    
    Since:
    
    3.1
  - clearImportedPackages
```
public void clearImportedPackages()
```
    Clear all the package names recorded by importPackage(). The java.lang package is not removed.
    
    Since:
    
    3.1
    
    See Also:
    
    importPackage(String)
  - getImportedPackages
```
public Iterator<String> getImportedPackages()
```
    Returns all the package names recorded by importPackage().
    
    Since:
    
    3.1
    
    See Also:
    
    importPackage(String)
  - recordInvalidClassName
```
public void recordInvalidClassName(String name)
```
    Records a name that never exists. For example, a package name can be recorded by this method. This would improve execution performance since get() does not search the class path at all if the given name is an invalid name recorded by this method. Note that searching the class path takes relatively long time.
    
    Parameters:
    
    name - a class name (separeted by dot).
  - getAndRename
```
public CtClass getAndRename(String orgName,
                            String newName)
                     throws NotFoundException
```
    Reads a class file and constructs a CtClass object with a new name. This method is useful if you want to generate a new class as a copy of another class (except the class name). For example,
    returns a CtClass object representing Pair class. The definition of Pair is the same as that of Point class except the class name since Pair is defined by reading Point.class.
    Parameters:
    
    orgName - the original (fully-qualified) class name
    
    newName - the new class name
    
    Throws:
    
    NotFoundException
  - get
```
public CtClass get(String classname)
            throws NotFoundException
```
    Reads a class file from the source and returns a reference to the CtClass object representing that class file. If that class file has been already read, this method returns a reference to the CtClass created when that class file was read at the first time.
    If classname ends with "[]", then this method returns a CtClass object for that array type.
    To obtain an inner class, use "$" instead of "." for separating the enclosing class name and the inner class name.
    
    Parameters:
    
    classname - a fully-qualified class name.
    
    Throws:
    
    NotFoundException
  - getOrNull
```
public CtClass getOrNull(String classname)
```
    Reads a class file from the source and returns a reference to the CtClass object representing that class file. This method is equivalent to get except that it returns null when a class file is not found and it never throws an exception.
    
    Parameters:
    
    classname - a fully-qualified class name.
    
    Returns:
    
    a CtClass object or null.
    
    Since:
    
    3.13
    
    See Also:
    
    get(String), find(String)
  - getCtClass
```
public CtClass getCtClass(String classname)
                   throws NotFoundException
```
    Returns a CtClass object with the given name. This is almost equivalent to get(String) except that classname can be an array-type "descriptor" (an encoded type name) such as [Ljava/lang/Object;.
    Using this method is not recommended; this method should be used only to obtain the CtClass object with a name returned from getClassInfo in javassist.bytecode.ClassPool. getClassInfo returns a fully-qualified class name but, if the class is an array type, it returns a descriptor.
    
    Parameters:
    
    classname - a fully-qualified class name or a descriptor representing an array type.
    
    Throws:
    
    NotFoundException
    
    Since:
    
    3.8.1
    
    See Also:
    
    get(String), ConstPool.getClassInfo(int), javassist.bytecode.Descriptor#toCtClass(String, ClassPool)
  - get0
```
protected CtClass get0(String classname,
                       boolean useCache)
                throws NotFoundException
```
    Parameters:
    
    useCache - false if the cached CtClass must be ignored.
    
    searchParent - false if the parent class pool is not searched.
    
    Returns:
    
    null if the class could not be found.
    
    Throws:
    
    NotFoundException
  - createCtClass
```
protected CtClass createCtClass(String classname,
                                boolean useCache)
```
    Creates a CtClass object representing the specified class. It first examines whether or not the corresponding class file exists. If yes, it creates a CtClass object.
    
    Returns:
    
    null if the class file could not be found.
  - find
```
public URL find(String classname)
```
    Searches the class path to obtain the URL of the class file specified by classname. It is also used to determine whether the class file exists.
    
    Parameters:
    
    classname - a fully-qualified class name.
    
    Returns:
    
    null if the class file could not be found.
    
    See Also:
    
    CtClass.getURL()
  - get
```
public CtClass[] get(String[] classnames)
              throws NotFoundException
```
    Reads class files from the source and returns an array of CtClass objects representing those class files.
    If an element of classnames ends with "[]", then this method returns a CtClass object for that array type.
    
    Parameters:
    
    classnames - an array of fully-qualified class name.
    
    Throws:
    
    NotFoundException
  - makeClass
```
public CtClass makeClass(InputStream classfile)
                  throws IOException,
                         RuntimeException
```
    Creates a new class (or interface) from the given class file. If there already exists a class with the same name, the new class overwrites that previous class.
    This method is used for creating a CtClass object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.
    
    Parameters:
    
    classfile - class file.
    
    Throws:
    
    RuntimeException - if there is a frozen class with the the same name.
    
    IOException
    
    See Also:
    
    makeClassIfNew(InputStream), javassist.ByteArrayClassPath
  - makeClass
```
public CtClass makeClass(InputStream classfile,
                         boolean ifNotFrozen)
                  throws IOException,
                         RuntimeException
```
    Creates a new class (or interface) from the given class file. If there already exists a class with the same name, the new class overwrites that previous class.
    This method is used for creating a CtClass object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.
    
    Parameters:
    
    classfile - class file.
    
    ifNotFrozen - throws a RuntimeException if this parameter is true and there is a frozen class with the same name.
    
    Throws:
    
    IOException
    
    RuntimeException
    
    See Also:
    
    javassist.ByteArrayClassPath
  - makeClassIfNew
```
public CtClass makeClassIfNew(InputStream classfile)
                       throws IOException,
                              RuntimeException
```
    Creates a new class (or interface) from the given class file. If there already exists a class with the same name, this method returns the existing class; a new class is never created from the given class file.
    This method is used for creating a CtClass object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.
    
    Parameters:
    
    classfile - the class file.
    
    Throws:
    
    IOException
    
    RuntimeException
    
    Since:
    
    3.9
    
    See Also:
    
    makeClass(InputStream), javassist.ByteArrayClassPath
  - makeClass
```
public CtClass makeClass(String classname)
                  throws RuntimeException
```
    Creates a new public class. If there already exists a class with the same name, the new class overwrites that previous class.
    If no constructor is explicitly added to the created new class, Javassist generates constructors and adds it when the class file is generated. It generates a new constructor for each constructor of the super class. The new constructor takes the same set of parameters and invokes the corresponding constructor of the super class. All the received parameters are passed to it.
    
    Parameters:
    
    classname - a fully-qualified class name.
    
    Throws:
    
    RuntimeException - if the existing class is frozen.
  - makeClass
```
public CtClass makeClass(String classname,
                         CtClass superclass)
                  throws RuntimeException
```
    Creates a new public class. If there already exists a class/interface with the same name, the new class overwrites that previous class.
    If no constructor is explicitly added to the created new class, Javassist generates constructors and adds it when the class file is generated. It generates a new constructor for each constructor of the super class. The new constructor takes the same set of parameters and invokes the corresponding constructor of the super class. All the received parameters are passed to it.
    
    Parameters:
    
    classname - a fully-qualified class name.
    
    superclass - the super class.
    
    Throws:
    
    RuntimeException - if the existing class is frozen.
  - makeInterface
```
public CtClass makeInterface(String name)
                      throws RuntimeException
```
    Creates a new public interface. If there already exists a class/interface with the same name, the new interface overwrites that previous one.
    
    Parameters:
    
    name - a fully-qualified interface name.
    
    Throws:
    
    RuntimeException - if the existing interface is frozen.
  - makeInterface
```
public CtClass makeInterface(String name,
                             CtClass superclass)
                      throws RuntimeException
```
    Creates a new public interface. If there already exists a class/interface with the same name, the new interface overwrites that previous one.
    
    Parameters:
    
    name - a fully-qualified interface name.
    
    superclass - the super interface.
    
    Throws:
    
    RuntimeException - if the existing interface is frozen.
  - appendSystemPath
```
public ClassPath appendSystemPath()
```
    Appends the system search path to the end of the search path. The system search path usually includes the platform library, extension libraries, and the search path specified by the -classpath option or the CLASSPATH environment variable.
    
    Returns:
    
    the appended class path.
  - insertClassPath
```
public ClassPath insertClassPath(ClassPath cp)
```
    Insert a ClassPath object at the head of the search path.
    
    Returns:
    
    the inserted class path.
    
    See Also:
    
    javassist.ClassPath, javassist.URLClassPath, javassist.ByteArrayClassPath
  - appendClassPath
```
public ClassPath appendClassPath(ClassPath cp)
```
    Appends a ClassPath object to the end of the search path.
    
    Returns:
    
    the appended class path.
    
    See Also:
    
    javassist.ClassPath, javassist.URLClassPath, javassist.ByteArrayClassPath
  - insertClassPath
```
public ClassPath insertClassPath(String pathname)
                          throws NotFoundException
```
    Inserts a directory or a jar (or zip) file at the head of the search path.
    
    Parameters:
    
    pathname - the path name of the directory or jar file. It must not end with a path separator ("/"). If the path name ends with "/*", then all the jar files matching the path name are inserted.
    
    Returns:
    
    the inserted class path.
    
    Throws:
    
    NotFoundException - if the jar file is not found.
  - appendClassPath
```
public ClassPath appendClassPath(String pathname)
                          throws NotFoundException
```
    Appends a directory or a jar (or zip) file to the end of the search path.
    
    Parameters:
    
    pathname - the path name of the directory or jar file. It must not end with a path separator ("/"). If the path name ends with "/*", then all the jar files matching the path name are appended.
    
    Returns:
    
    the appended class path.
    
    Throws:
    
    NotFoundException - if the jar file is not found.
  - removeClassPath
```
public void removeClassPath(ClassPath cp)
```
    Detatches the ClassPath object from the search path. The detached ClassPath object cannot be added to the pathagain.
  - appendPathList
```
public void appendPathList(String pathlist)
                    throws NotFoundException
```
    Appends directories and jar files for search.
    The elements of the given path list must be separated by colons in Unix or semi-colons in Windows.
    
    Parameters:
    
    pathlist - a (semi)colon-separated list of the path names of directories and jar files. The directory name must not end with a path separator ("/").
    
    Throws:
    
    NotFoundException - if a jar file is not found.
  - getClassLoader
```
public ClassLoader getClassLoader()
```
    Get the classloader for toClass(), getAnnotations() in CtClass, etc.
    The default is the context class loader.
    
    Returns:
    
    the classloader for the pool
    
    See Also:
    
    #toClass(CtClass), CtClass.getAnnotations()

Class ClassPool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

childFirstLookup

doPruning

releaseUnmodifiedClassFile

source

parent

classes

Constructor Detail

ClassPool

ClassPool

ClassPool

Method Detail

getDefault

getCached

cacheCtClass

removeCached

toString

importPackage

clearImportedPackages

getImportedPackages

recordInvalidClassName

getAndRename

get

getOrNull

getCtClass

get0

createCtClass

find

get

makeClass

makeClass

makeClassIfNew

makeClass

makeClass

makeInterface

makeInterface

appendSystemPath

insertClassPath

appendClassPath

insertClassPath

appendClassPath

removeClassPath

appendPathList

getClassLoader