Uses of Class
javassist.NotFoundException

Packages that use NotFoundException

Package	Description
javassist	The Javassist Core API.
javassist.bytecode	Bytecode-level API.
javassist.bytecode.analysis	Bytecode Analysis API.
javassist.bytecode.annotation	Bytecode-level Annotations API.
javassist.bytecode.stackmap
javassist.compiler
javassist.convert
javassist.expr	This package contains the classes for modifying a method body.
javassist.scopedpool	A custom class pool for several JBoss products.
javassist.tools.reflect	Runtime Behavioral Reflection.
javassist.tools.rmi	Sample implementation of remote method invocation.
javassist.tools.web	Simple web server for running sample code.
javassist.util	Utility classes.

Uses of NotFoundException in javassist

Methods in javassist that throw NotFoundException

Modifier and Type	Method	Description
static CtMethod	CtNewMethod.abstractMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, CtClass declaring)	Creates a public abstract method.
void	Loader.addTranslator(ClassPool cp, Translator t)	Adds a translator, which is called whenever a class is loaded.
ClassPath	ClassPool.appendClassPath(String pathname)	Appends a directory or a jar (or zip) file to the end of the search path.
ClassPath	ClassPoolTail.appendClassPath(String pathname)
void	ClassPool.appendPathList(String pathlist)	Appends directories and jar files for search.
static CtField.Initializer	CtField.Initializer.byNewArray(CtClass type, int size)	Makes an initializer creating a new array.
private CtField	CtClassType.checkGetField(CtField f, String name, String desc)
private static CtMethod	CtNewMethod.delegator0(CtMethod delegate, CtClass declaring)
CtClass	ClassPool.get(String classname)	Reads a class file from the source and returns a reference to the CtClass object representing that class file.
CtClass[]	ClassPool.get(String[] classnames)	Reads class files from the source and returns an array of CtClass objects representing those class files.
protected CtClass	ClassPool.get0(String classname, boolean useCache)
CtClass	ClassPool.getAndRename(String orgName, String newName)	Reads a class file and constructs a CtClass object with a new name.
CtClass	CtArray.getComponentType()
CtClass	CtClass.getComponentType()	If this object represents an array, this method returns the component type of the array.
CtConstructor	CtClass.getConstructor(String desc)	Returns the constructor with the given signature, which is represented by a character string called method descriptor.
CtConstructor	CtClassType.getConstructor(String desc)
CtClass	ClassPool.getCtClass(String classname)	Returns a CtClass object with the given name.
CtClass[]	CtClass.getDeclaredClasses()	Returns an array of nested classes declared in the class.
CtConstructor	CtClass.getDeclaredConstructor(CtClass[] params)	Returns a constructor receiving the specified parameters.
CtField	CtClass.getDeclaredField(String name)	Retrieves the field with the specified name among the fields declared in the class.
CtField	CtClass.getDeclaredField(String name, String desc)	Retrieves the field with the specified name and type among the fields declared in the class.
CtField	CtClassType.getDeclaredField(String name)
CtField	CtClassType.getDeclaredField(String name, String desc)
CtMethod	CtClass.getDeclaredMethod(String name)	Retrieves the method with the specified name among the methods declared in the class.
CtMethod	CtClass.getDeclaredMethod(String name, CtClass[] params)	Retrieves the method with the specified name and parameter types among the methods declared in the class.
CtMethod	CtClassType.getDeclaredMethod(String name)
CtMethod	CtClassType.getDeclaredMethod(String name, CtClass[] params)
CtMethod[]	CtClass.getDeclaredMethods(String name)	Retrieves methods with the specified name among the methods declared in the class.
CtMethod[]	CtClassType.getDeclaredMethods(String name)
CtClass	CtClass.getDeclaringClass()	If this class is a member class or interface of another class, then the class enclosing this class is returned.
CtClass	CtClassType.getDeclaringClass()
CtBehavior	CtClass.getEnclosingBehavior()	Returns the immediately enclosing method of this class.
CtBehavior	CtClassType.getEnclosingBehavior()
final CtMethod	CtClass.getEnclosingMethod()	Deprecated. The enclosing method might be a constructor.
CtClass[]	CtBehavior.getExceptionTypes()	Obtains exceptions that this method/constructor may throw.
CtField	CtClass.getField(String name)	Returns the field with the specified name.
CtField	CtClass.getField(String name, String desc)	Returns the field with the specified name and type.
CtField	CtClassType.getField(String name, String desc)
CtClass[]	CtArray.getInterfaces()
CtClass[]	CtClass.getInterfaces()	Obtains the class objects representing the interfaces implemented by the class or, if this object represents an interface, the interfaces extended by that interface.
CtClass[]	CtClassType.getInterfaces()
CtMethod	ClassPool.getMethod(String classname, String methodname)	Reads a class file and obtains a compile-time method.
CtMethod	CtArray.getMethod(String name, String desc)
CtMethod	CtClass.getMethod(String name, String desc)	Returns the method with the given name and signature.
CtMethod	CtClassType.getMethod(String name, String desc)
CtClass[]	CtClass.getNestedClasses()	Returns an array of nested classes declared in the class.
CtClass[]	CtClassType.getNestedClasses()
CtClass[]	CtBehavior.getParameterTypes()	Obtains parameter types of this method/constructor.
CtClass	CtMethod.getReturnType()	Obtains the type of the returned value.
(package private) CtClass	CtBehavior.getReturnType0()	Obtains the type of the returned value.
CtClass	CtArray.getSuperclass()
CtClass	CtClass.getSuperclass()	Obtains the class object representing the superclass of the class.
CtClass	CtClassType.getSuperclass()
CtClass	CtField.getType()	Returns the type of the field.
URL	CtClass.getURL()	Returns the uniform resource locator (URL) of the class file.
URL	CtClassType.getURL()
void	CtNewClass.inheritAllConstructors()	Adds constructors inhrited from the super class.
ClassPath	ClassPool.insertClassPath(String pathname)	Inserts a directory or a jar (or zip) file at the head of the search path.
ClassPath	ClassPoolTail.insertClassPath(String pathname)
private static boolean	SerialVersionUID.isSerializable(CtClass clazz)	Does the class implement Serializable?
private int	CtClassType.makeFieldInitializer(Bytecode code, CtClass[] parameters)
private static ClassPath	ClassPoolTail.makePathObject(String pathname)
private void	CtClassType.modifyClassConstructor(ClassFile cf)
private void	CtClassType.modifyConstructors(ClassFile cf)
void	Translator.onLoad(ClassPool pool, String classname)	Is invoked by a Loader for notifying that a class is loaded.
InputStream	ClassClassPath.openClassfile(String classname)	Obtains a class file by getResourceAsStream().
InputStream	ClassPath.openClassfile(String classname)	Opens a class file.
(package private) InputStream	ClassPool.openClassfile(String classname)
(package private) InputStream	ClassPoolTail.openClassfile(String classname)	Opens the class file for the class specified by classname.
InputStream	JarClassPath.openClassfile(String classname)
InputStream	JarDirClassPath.openClassfile(String classname)
InputStream	LoaderClassPath.openClassfile(String classname)	Obtains a class file from the class loader.
void	CtClass.removeConstructor(CtConstructor c)	Removes a constructor declared in this class.
void	CtClassType.removeConstructor(CtConstructor m)
void	CtClass.removeField(CtField f)	Removes a field declared in this class.
void	CtClassType.removeField(CtField f)
void	CtClass.removeMethod(CtMethod m)	Removes a method declared in this class.
void	CtClassType.removeMethod(CtMethod m)
void	CodeConverter.replaceArrayAccess(CtClass calledClass, CodeConverter.ArrayAccessReplacementMethodNames names)	Modify a method body, so that ALL accesses to an array are replaced with calls to static methods within another class.
void	CtBehavior.setExceptionTypes(CtClass[] types)	Sets exceptions that this method/constructor may throw.
static void	SerialVersionUID.setSerialVersionUID(CtClass clazz)	Adds serialVersionUID if one does not already exist.
void	Translator.start(ClassPool pool)	Is invoked by a Loader for initialization when the object is attached to the Loader object.
boolean	CtArray.subtypeOf(CtClass clazz)
boolean	CtClass.subtypeOf(CtClass clazz)	Returns true if this class extends or implements clazz.
boolean	CtClassType.subtypeOf(CtClass clazz)
(package private) void	ClassPool.writeClassfile(String classname, OutputStream out)
(package private) void	ClassPoolTail.writeClassfile(String classname, OutputStream out)	This method does not close the output stream.
void	CtClass.writeFile()	Writes a class file represented by this CtClass object in the current directory.

Constructors in javassist with parameters of type NotFoundException

Modifier	Constructor	Description
	CannotCompileException(NotFoundException e)	Constructs a CannotCompileException with a NotFoundException.

Constructors in javassist that throw NotFoundException

Modifier	Constructor	Description
(package private)	JarClassPath(String pathname)
(package private)	JarDirClassPath(String dirName)

Uses of NotFoundException in javassist.bytecode

Methods in javassist.bytecode that throw NotFoundException

Modifier and Type	Method	Description
static CtClass[]	Descriptor.getParameterTypes(String desc, ClassPool cp)	Returns the CtClass objects representing the parameter types specified by the given descriptor.
static CtClass	Descriptor.getReturnType(String desc, ClassPool cp)	Returns the CtClass object representing the return type specified by the given descriptor.
static CtClass	Descriptor.toCtClass(String desc, ClassPool cp)	Returns a CtClass object representing the type specified by the given descriptor.
private static int	Descriptor.toCtClass(ClassPool cp, String desc, int i, CtClass[] args, int n)

Uses of NotFoundException in javassist.bytecode.analysis

Methods in javassist.bytecode.analysis that throw NotFoundException

Modifier and Type	Method	Description
private static CtClass	Type.findCommonSuperClass(CtClass one, CtClass two)
private Type	Type.mergeClasses(Type type)

Uses of NotFoundException in javassist.bytecode.annotation

Methods in javassist.bytecode.annotation that throw NotFoundException

Modifier and Type	Method	Description
static MemberValue	Annotation.createMemberValue(ConstPool cp, CtClass type)	Makes an instance of MemberValue.

Constructors in javassist.bytecode.annotation that throw NotFoundException

Modifier	Constructor	Description
	Annotation(ConstPool cp, CtClass clazz)	Constructs an annotation that can be accessed through the interface represented by clazz.

Uses of NotFoundException in javassist.bytecode.stackmap

Methods in javassist.bytecode.stackmap that throw NotFoundException

Modifier and Type	Method	Description
static CtClass	TypeData.commonSuperClass(CtClass one, CtClass two)	Finds the most specific common super class of the given classes.
static CtClass	TypeData.commonSuperClassEx(CtClass one, CtClass two)	Finds the most specific common super class of the given classes by considering array types.
int	TypeData.ArrayElement.dfs(List<TypeData> order, int index, ClassPool cp)
int	TypeData.ArrayType.dfs(List<TypeData> order, int index, ClassPool cp)
int	TypeData.dfs(List<TypeData> order, int index, ClassPool cp)	Depth-first search by Tarjan's algorithm
int	TypeData.TypeVar.dfs(List<TypeData> preOrder, int index, ClassPool cp)
private CtClass	TypeData.TypeVar.fixByUppers(List<TypeData> users, ClassPool cp, Set<TypeData> visited, CtClass type)
private void	MapMaker.fixTypes(byte[] code, TypedBlock[] blocks)
private void	TypeData.TypeVar.fixTypes(List<TypeData> scc, ClassPool cp)
private void	TypeData.TypeVar.fixTypes1(List<TypeData> scc, TypeData kind)
private String	TypeData.TypeVar.fixTypes2(List<TypeData> scc, Set<String> lowersSet, ClassPool cp)
TypeData	TypeData.ArrayElement.getArrayType(int dim)
TypeData	TypeData.ArrayType.getArrayType(int dim)
TypeData	TypeData.BasicType.getArrayType(int dim)
TypeData	TypeData.ClassName.getArrayType(int dim)
abstract TypeData	TypeData.getArrayType(int dim)
TypeData	TypeData.TypeVar.getArrayType(int dim)
TypeData	TypeData.UninitTypeVar.getArrayType(int dim)
private static boolean	TypeData.TypeVar.isObjectArray(CtClass cc)

Uses of NotFoundException in javassist.compiler

Methods in javassist.compiler that throw NotFoundException

Modifier and Type	Method	Description
private CtClass	MemberResolver.lookupClass0(String classname, boolean notCheckInner)

Constructors in javassist.compiler with parameters of type NotFoundException

Modifier	Constructor	Description
	CompileError(NotFoundException e)

Uses of NotFoundException in javassist.convert

Constructors in javassist.convert that throw NotFoundException

Modifier	Constructor	Description
	TransformAccessArrayField(Transformer next, String methodClassname, CodeConverter.ArrayAccessReplacementMethodNames names)
	TransformAfter(Transformer next, CtMethod origMethod, CtMethod afterMethod)
	TransformBefore(Transformer next, CtMethod origMethod, CtMethod beforeMethod)

Uses of NotFoundException in javassist.expr

Methods in javassist.expr that throw NotFoundException

Modifier and Type	Method	Description
CtClass	NewArray.getComponentType()	Returns the type of array components.
CtConstructor	ConstructorCall.getConstructor()	Returns the called constructor.
CtConstructor	NewExpr.getConstructor()	Returns the constructor called for creating the object.
private CtClass	FieldAccess.getCtClass()	Returns the class in which the field is declared.
protected CtClass	MethodCall.getCtClass()	Returns the class of the target object, which the method is called on.
private CtClass	NewExpr.getCtClass()	Returns the class of the created object.
CtField	FieldAccess.getField()	Returns the field accessed by this expression.
CtMethod	ConstructorCall.getMethod()	Always throws a NotFoundException.
CtMethod	MethodCall.getMethod()	Returns the called method.
CtClass	Cast.getType()	Returns the CtClass object representing the type specified by the cast.
CtClass	Handler.getType()	Returns the type handled by the catch clause.
CtClass	Instanceof.getType()	Returns the CtClass object representing the type name on the right hand side of the instanceof operator.
private void	NewArray.replace2(String statement)

Uses of NotFoundException in javassist.scopedpool

Methods in javassist.scopedpool that throw NotFoundException

Modifier and Type	Method	Description
CtClass	ScopedClassPool.getLocally(String classname)	Get any local copy of the class

Uses of NotFoundException in javassist.tools.reflect

Methods in javassist.tools.reflect that throw NotFoundException

Modifier and Type	Method	Description
private CtMethod	Reflection.findOriginal(CtMethod m, boolean dontSearch)
boolean	Loader.makeReflective(String clazz, String metaobject, String metaclass)	Produces a reflective class.
boolean	Reflection.makeReflective(Class<?> clazz, Class<?> metaobject, Class<?> metaclass)	Produces a reflective class.
boolean	Reflection.makeReflective(String classname, String metaobject, String metaclass)	Produces a reflective class.
boolean	Reflection.makeReflective(CtClass clazz, CtClass metaobject, CtClass metaclass)	Produces a reflective class.
private boolean	Reflection.modifyClassfile(CtClass clazz, CtClass metaobject, CtClass metaclass)
void	Reflection.onLoad(ClassPool pool, String classname)	Inserts hooks for intercepting accesses to the fields declared in reflective classes.
private void	Reflection.processFields(CtClass clazz)
private void	Reflection.processMethods(CtClass clazz, boolean dontSearch)
private void	Reflection.processMethods0(int mod, CtClass clazz, CtMethod m, int identifier, boolean dontSearch)
void	Reflection.start(ClassPool pool)	Initializes the object.

Constructors in javassist.tools.reflect that throw NotFoundException

Modifier	Constructor	Description
	Loader()	Constructs a new class loader.

Uses of NotFoundException in javassist.tools.rmi

Methods in javassist.tools.rmi that throw NotFoundException

Modifier and Type	Method	Description
private void	StubGenerator.addMethods(CtClass proxy, Method[] ms)
boolean	StubGenerator.makeProxyClass(Class<?> clazz)	Makes a proxy class.
private void	StubGenerator.modifySuperclass(CtClass orgclass)	Adds a default constructor to the super classes.
private CtClass	StubGenerator.produceProxyClass(CtClass orgclass, Class<?> orgRtClass)
void	StubGenerator.start(ClassPool pool)	Initializes the object.
private CtClass	StubGenerator.toCtClass(Class<?> rtclass)
private CtClass[]	StubGenerator.toCtClass(Class<?>[] rtclasses)

Constructors in javassist.tools.rmi that throw NotFoundException

Modifier	Constructor	Description
	AppletServer(int port)	Constructs a web server.
	AppletServer(int port, ClassPool src)	Constructs a web server.
	AppletServer(String port)	Constructs a web server.
private	AppletServer(ClassPool loader, StubGenerator gen, int port)

Uses of NotFoundException in javassist.tools.web

Methods in javassist.tools.web that throw NotFoundException

Modifier and Type	Method	Description
void	Webserver.addTranslator(ClassPool cp, Translator t)	Adds a translator, which is called whenever a client requests a class file.

Uses of NotFoundException in javassist.util

Methods in javassist.util that throw NotFoundException

Modifier and Type	Method	Description
static File	HotSwapAgent.createAgentJarFile(String fileName)	Creates an agent file for using HotSwapAgent.
private static File	HotSwapAgent.createJarFile()
private static File	HotSwapAgent.createJarFile(File jar)
static void	HotSwapAgent.redefine(Class<?>[] oldClasses, CtClass[] newClasses)	Redefines classes.
static void	HotSwapAgent.redefine(Class<?> oldClass, CtClass newClass)	Redefines a class.
private static void	HotSwapAgent.startAgent()	Ensures that the agent is ready.