Uses of Class
javassist.CtClass

Packages that use CtClass

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.expr	This package contains the classes for modifying a method body.
javassist.tools.reflect	Runtime Behavioral Reflection.
javassist.util	Utility classes.

Uses of CtClass in javassist

Subclasses of CtClass in javassist

Modifier and Type	Class	Description
final class	CtPrimitiveType	An instance of CtPrimitiveType represents a primitive type.

Fields in javassist declared as CtClass

Modifier and Type	Field	Description
static CtClass	CtClass.booleanType	The CtClass object representing the boolean type.
static CtClass	CtClass.byteType	The CtClass object representing the byte type.
static CtClass	CtClass.charType	The CtClass object representing the char type.
static CtClass	CtClass.doubleType	The CtClass object representing the double type.
static CtClass	CtClass.floatType	The CtClass object representing the float type.
static CtClass	CtClass.intType	The CtClass object representing the int type.
static CtClass	CtClass.longType	The CtClass object representing the long type.
static CtClass	CtClass.shortType	The CtClass object representing the short type.
static CtClass	CtClass.voidType	The CtClass object representing the void type.

Methods in javassist that return CtClass

Modifier and Type	Method	Description
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.
CtClass	ClassPool.getAndRename(String orgName, String newName)	Reads a class file and constructs a CtClass object with a new name.
CtClass	CtClass.getComponentType()	If this object represents an array, this method returns the component type of the array.
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.
CtClass	CtClass.getDeclaringClass()	If this class is a member class or interface of another class, then the class enclosing this class is returned.
CtClass	CtField.getDeclaringClass()	Returns the class declaring the field.
CtClass	CtMember.getDeclaringClass()	Returns the class that declares this member.
CtClass[]	CtBehavior.getExceptionTypes()	Obtains exceptions that this method/constructor may throw.
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[]	CtClass.getNestedClasses()	Returns an array of nested classes declared in the class.
CtClass	ClassPool.getOrNull(String classname)	Reads a class file from the source and returns a reference to the CtClass object representing that class file.
CtClass[]	CtBehavior.getParameterTypes()	Obtains parameter types of this method/constructor.
CtClass	CtMethod.getReturnType()	Obtains the type of the returned value.
CtClass	CtClass.getSuperclass()	Obtains the class object representing the superclass of the class.
CtClass	CtField.getType()	Returns the type of the field.
CtClass	ClassPool.makeAnnotation(String name)	Creates a new annotation.
CtClass	ClassPool.makeClass(InputStream classfile)	Creates a new class (or interface) from the given class file.
CtClass	ClassPool.makeClass(InputStream classfile, boolean ifNotFrozen)	Creates a new class (or interface) from the given class file.
CtClass	ClassPool.makeClass(String classname)	Creates a new public class.
CtClass	ClassPool.makeClass(String classname, CtClass superclass)	Creates a new public class.
CtClass	ClassPool.makeClass(ClassFile classfile)	Creates a new class (or interface) from the given class file.
CtClass	ClassPool.makeClass(ClassFile classfile, boolean ifNotFrozen)	Creates a new class (or interface) from the given class file.
CtClass	ClassPool.makeClassIfNew(InputStream classfile)	Creates a new class (or interface) from the given class file.
CtClass	ClassPool.makeInterface(String name)	Creates a new public interface.
CtClass	ClassPool.makeInterface(String name, CtClass superclass)	Creates a new public interface.
CtClass	CtClass.makeNestedClass(String name, boolean isStatic)	Makes a new public nested class.

Methods in javassist with parameters of type CtClass

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	CtBehavior.addCatch(String src, CtClass exceptionType)	Adds a catch clause that handles an exception thrown in the body.
void	CtBehavior.addCatch(String src, CtClass exceptionType, String exceptionName)	Adds a catch clause that handles an exception thrown in the body.
void	CtClass.addInterface(CtClass anInterface)	Adds an interface.
void	CtBehavior.addLocalVariable(String name, CtClass type)	Declares a new local variable.
void	CtBehavior.addParameter(CtClass type)	Appends a new parameter, which becomes the last parameter.
static CtField.Initializer	CtField.Initializer.byCall(CtClass methodClass, String methodName)	Makes an initializer calling a static method.
static CtField.Initializer	CtField.Initializer.byCall(CtClass methodClass, String methodName, String[] stringParams)	Makes an initializer calling a static method.
static CtField.Initializer	CtField.Initializer.byCallWithParams(CtClass methodClass, String methodName)	Makes an initializer calling a static method.
static CtField.Initializer	CtField.Initializer.byCallWithParams(CtClass methodClass, String methodName, String[] stringParams)	Makes an initializer calling a static method.
static CtField.Initializer	CtField.Initializer.byNew(CtClass objectType)	Makes an initializer creating a new object.
static CtField.Initializer	CtField.Initializer.byNew(CtClass objectType, String[] stringParams)	Makes an initializer creating a new object.
static CtField.Initializer	CtField.Initializer.byNewArray(CtClass type, int size)	Makes an initializer creating a new array.
static CtField.Initializer	CtField.Initializer.byNewArray(CtClass type, int[] sizes)	Makes an initializer creating a new multi-dimensional array.
static CtField.Initializer	CtField.Initializer.byNewWithParams(CtClass objectType)	Makes an initializer creating a new object.
static CtField.Initializer	CtField.Initializer.byNewWithParams(CtClass objectType, String[] stringParams)	Makes an initializer creating a new object.
static long	SerialVersionUID.calculateDefault(CtClass clazz)	Calculate default value.
static CtConstructor	CtNewConstructor.copy(CtConstructor c, CtClass declaring, ClassMap map)	Creates a copy of a constructor.
static CtMethod	CtNewMethod.copy(CtMethod src, String name, CtClass declaring, ClassMap map)	Creates a copy of a method with a new name.
static CtMethod	CtNewMethod.copy(CtMethod src, CtClass declaring, ClassMap map)	Creates a copy of a method.
static CtConstructor	CtNewConstructor.defaultConstructor(CtClass declaring)	Creates a default (public) constructor.
static CtMethod	CtNewMethod.delegator(CtMethod delegate, CtClass declaring)	Creates a method forwarding to a delegate in a super class.
void	ClassMap.fix(CtClass clazz)	Prevents a mapping from the specified class name to another name.
CtConstructor	CtClass.getDeclaredConstructor(CtClass[] params)	Returns a constructor receiving the specified parameters.
CtMethod	CtClass.getDeclaredMethod(String name, CtClass[] params)	Retrieves the method with the specified name and parameter types among the methods declared in the class.
void	CtBehavior.insertParameter(CtClass type)	Inserts a new parameter, which becomes the first parameter.
Class<?>	Loader.Simple.invokeDefineClass(CtClass cc)	Invokes the protected defineClass() in ClassLoader.
static CtField	CtField.make(String src, CtClass declaring)	Compiles the given source code and creates a field.
static CtMethod	CtMethod.make(String src, CtClass declaring)	Compiles the given source code and creates a method.
static CtMethod	CtMethod.make(MethodInfo minfo, CtClass declaring)	Creates a method from a MethodInfo object.
static CtConstructor	CtNewConstructor.make(String src, CtClass declaring)	Compiles the given source code and creates a constructor.
static CtConstructor	CtNewConstructor.make(CtClass[] parameters, CtClass[] exceptions, int howto, CtMethod body, CtMethod.ConstParameter cparam, CtClass declaring)	Creates a public constructor.
static CtConstructor	CtNewConstructor.make(CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)	Creates a public constructor.
static CtConstructor	CtNewConstructor.make(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)	Creates a public constructor that only calls a constructor in the super class.
static CtMethod	CtNewMethod.make(int modifiers, CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)	Creates a method.
static CtMethod	CtNewMethod.make(String src, CtClass declaring)	Compiles the given source code and creates a method.
static CtMethod	CtNewMethod.make(String src, CtClass declaring, String delegateObj, String delegateMethod)	Compiles the given source code and creates a method.
static CtMethod	CtNewMethod.make(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)	Creates a public (non-static) method.
CtClass	ClassPool.makeClass(String classname, CtClass superclass)	Creates a new public class.
CtClass	ClassPool.makeInterface(String name, CtClass superclass)	Creates a new public interface.
void	ClassMap.put(CtClass oldname, CtClass newname)	Maps a class name to another name in this hashtable.
void	CodeConverter.redirectFieldAccess(CtField field, CtClass newClass, String newFieldname)	Modify a method body so that field read/write expressions access a different field from the original one.
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	CodeConverter.replaceFieldRead(CtField field, CtClass calledClass, String calledMethod)	Modify a method body so that an expression reading the specified field is replaced with a call to the specified static method.
void	CodeConverter.replaceFieldWrite(CtField field, CtClass calledClass, String calledMethod)	Modify a method body so that an expression writing the specified field is replaced with a call to the specified static method.
void	CodeConverter.replaceNew(CtClass oldClass, CtClass newClass)	Modify a method body so that instantiation of the class specified by oldClass is replaced with instantiation of another class newClass.
void	CodeConverter.replaceNew(CtClass newClass, CtClass calledClass, String calledMethod)	Modify a method body so that instantiation of the specified class is replaced with a call to the specified static method.
void	CtBehavior.setExceptionTypes(CtClass[] types)	Sets exceptions that this method/constructor may throw.
void	CtClass.setInterfaces(CtClass[] list)	Sets implemented interfaces.
static void	SerialVersionUID.setSerialVersionUID(CtClass clazz)	Adds serialVersionUID if one does not already exist.
void	CtClass.setSuperclass(CtClass clazz)	Changes a super class unless this object represents an interface.
void	CtField.setType(CtClass clazz)	Sets the type of the field.
static CtConstructor	CtNewConstructor.skeleton(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)	Creates a public constructor that only calls a constructor in the super class.
boolean	CtClass.subclassOf(CtClass superclass)	Determines whether the class directly or indirectly extends the given class.
boolean	CtClass.subtypeOf(CtClass clazz)	Returns true if this class extends or implements clazz.
Class	ClassPool.toClass(CtClass clazz)	Converts the given class to a java.lang.Class object.
Class<?>	ClassPool.toClass(CtClass ct, Class<?> neighbor)	Converts the class to a java.lang.Class object.
Class	ClassPool.toClass(CtClass ct, Class<?> neighbor, ClassLoader loader, ProtectionDomain domain)	Converts the class to a java.lang.Class object.
Class	ClassPool.toClass(CtClass ct, ClassLoader loader)	Deprecated. Replaced by ClassPool.toClass(CtClass,Class,ClassLoader,ProtectionDomain).
Class	ClassPool.toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)	Deprecated. Replaced by ClassPool.toClass(CtClass,Class,ClassLoader,ProtectionDomain).
Class<?>	ClassPool.toClass(CtClass ct, MethodHandles.Lookup lookup)	Converts the class to a java.lang.Class object.
CtMethod	CtConstructor.toMethod(String name, CtClass declaring)	Makes a copy of this constructor and converts it into a method.
CtMethod	CtConstructor.toMethod(String name, CtClass declaring, ClassMap map)	Makes a copy of this constructor and converts it into a method.
boolean	CtMember.visibleFrom(CtClass clazz)	Returns true if this member is accessible from the given class.
static CtMethod	CtNewMethod.wrapped(CtClass returnType, String mname, CtClass[] parameterTypes, CtClass[] exceptionTypes, CtMethod body, CtMethod.ConstParameter constParam, CtClass declaring)	Creates a wrapped method.

Constructors in javassist with parameters of type CtClass

Modifier	Constructor	Description
	CtConstructor(CtClass[] parameters, CtClass declaring)	Creates a constructor with no constructor body.
	CtConstructor(CtConstructor src, CtClass declaring, ClassMap map)	Creates a copy of a CtConstructor object.
	CtField(CtClass type, String name, CtClass declaring)	Creates a CtField object.
	CtField(CtField src, CtClass declaring)	Creates a copy of the given field.
	CtMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass declaring)	Creates a public abstract method.
	CtMethod(CtMethod src, CtClass declaring, ClassMap map)	Creates a copy of a CtMethod object.

Uses of CtClass in javassist.bytecode

Fields in javassist.bytecode declared as CtClass

Modifier and Type	Field	Description
static final CtClass	Bytecode.THIS	Represents the CtClass file using the constant pool table given to this Bytecode object.
static final CtClass	ConstPool.THIS	Represents the class using this constant pool table.

Methods in javassist.bytecode that return CtClass

Modifier and Type	Method	Description
CtClass	SignatureAttribute.BaseType.getCtlass()	Returns the CtClass representing this primitive type.
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.

Methods in javassist.bytecode with parameters of type CtClass

Modifier and Type	Method	Description
void	Bytecode.addAnewarray(CtClass clazz, int length)	Appends ICONST and ANEWARRAY.
void	Bytecode.addCheckcast(CtClass c)	Appends CHECKCAST.
int	ConstPool.addClassInfo(CtClass c)	Adds a new CONSTANT_Class_info structure.
void	Bytecode.addConstZero(CtClass type)	Appends an instruction for pushing zero or null on the stack.
void	Bytecode.addExceptionHandler(int start, int end, int handler, CtClass type)	Adds a new entry of exception_table.
void	Bytecode.addGetfield(CtClass c, String name, String type)	Appends GETFIELD.
void	Bytecode.addGetstatic(CtClass c, String name, String type)	Appends GETSTATIC.
void	Bytecode.addInvokeinterface(CtClass clazz, String name, String desc, int count)	Appends INVOKEINTERFACE.
void	Bytecode.addInvokeinterface(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes, int count)	Appends INVOKEINTERFACE.
void	Bytecode.addInvokespecial(CtClass clazz, String name, String desc)	Appends INVOKESPECIAL.
void	Bytecode.addInvokespecial(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes)	Appends INVOKESPECIAL.
void	Bytecode.addInvokestatic(CtClass clazz, String name, String desc)	Appends INVOKESTATIC.
void	Bytecode.addInvokestatic(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes)	Appends INVOKESTATIC.
void	Bytecode.addInvokevirtual(CtClass clazz, String name, String desc)	Appends INVOKEVIRTUAL.
void	Bytecode.addInvokevirtual(CtClass clazz, String name, CtClass returnType, CtClass[] paramTypes)	Appends INVOKEVIRTUAL.
int	Bytecode.addLoad(int n, CtClass type)	Appends an instruction for loading a value from the local variable at the index n.
int	Bytecode.addLoadParameters(CtClass[] params, int offset)	Appends instructions for loading all the parameters onto the operand stack.
int	Bytecode.addMultiNewarray(CtClass clazz, int dim)	Appends MULTINEWARRAY.
int	Bytecode.addMultiNewarray(CtClass clazz, int[] dimensions)	Appends MULTINEWARRAY.
void	Bytecode.addNew(CtClass clazz)	Appends NEW.
void	Bytecode.addPutfield(CtClass c, String name, String desc)	Appends PUTFIELD.
void	Bytecode.addPutstatic(CtClass c, String name, String desc)	Appends PUTSTATIC.
void	Bytecode.addReturn(CtClass type)	Appends ARETURN, IRETURN, .., or RETURN.
int	Bytecode.addStore(int n, CtClass type)	Appends an instruction for storing a value into the local variable at the index n.
static String	Descriptor.appendParameter(CtClass type, String descriptor)	Appends a parameter type to the parameter list represented by the given descriptor.
static String	Descriptor.insertParameter(CtClass type, String descriptor)	Inserts a parameter type at the beginning of the parameter list represented by the given descriptor.
static String	Descriptor.of(CtClass type)	Returns the descriptor representing the given type.
static String	Descriptor.ofConstructor(CtClass[] paramTypes)	Returns the descriptor representing a constructor receiving the given parameter types.
static String	Descriptor.ofMethod(CtClass returnType, CtClass[] paramTypes)	Returns the descriptor representing a method that receives the given parameter types and returns the given type.
static String	Descriptor.ofParameters(CtClass[] paramTypes)	Returns the descriptor representing a list of parameter types.
void	Bytecode.setMaxLocals(boolean isStatic, CtClass[] params, int locals)	Sets max_locals.
static String	Descriptor.toJvmName(CtClass clazz)	Returns the internal representation of the class name in the JVM.

Uses of CtClass in javassist.bytecode.analysis

Methods in javassist.bytecode.analysis that return CtClass

Modifier and Type	Method	Description
CtClass	MultiArrayType.getCtClass()
CtClass	MultiType.getCtClass()	Gets the class that corresponds with this type.
CtClass	Type.getCtClass()	Returns the class this type represents.

Methods in javassist.bytecode.analysis with parameters of type CtClass

Modifier and Type	Method	Description
Frame[]	Analyzer.analyze(CtClass clazz, MethodInfo method)	Performs data-flow analysis on a method and returns an array, indexed by instruction position, containing the starting frame state of all reachable instructions.
static Type	Type.get(CtClass clazz)	Obtain the Type for a given class.
void	FramePrinter.print(CtClass clazz)	Prints all the methods declared in the given class.
static void	FramePrinter.print(CtClass clazz, PrintStream stream)	Prints all the methods declared in the given class.

Constructors in javassist.bytecode.analysis with parameters of type CtClass

Modifier	Constructor	Description
	ControlFlow(CtClass ctclazz, MethodInfo minfo)	Constructs a control-flow analyzer.

Constructor parameters in javassist.bytecode.analysis with type arguments of type CtClass

Modifier	Constructor	Description
	MultiType(Map<String,CtClass> interfaces)
	MultiType(Map<String,CtClass> interfaces, Type potentialClass)

Uses of CtClass in javassist.bytecode.annotation

Methods in javassist.bytecode.annotation with parameters of type CtClass

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

Constructors in javassist.bytecode.annotation with parameters of type CtClass

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

Uses of CtClass in javassist.expr

Methods in javassist.expr that return CtClass

Modifier and Type	Method	Description
CtClass	NewArray.getComponentType()	Returns the type of array components.
CtClass	Expr.getEnclosingClass()	Returns the class that declares the method enclosing this expression.
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.
CtClass[]	Cast.mayThrow()	Returns the list of exceptions that the expression may throw.
CtClass[]	Expr.mayThrow()	Returns the list of exceptions that the expression may throw.
CtClass[]	FieldAccess.mayThrow()	Returns the list of exceptions that the expression may throw.
CtClass[]	Handler.mayThrow()	Returns the list of exceptions that the catch clause may throw.
CtClass[]	Instanceof.mayThrow()	Returns the list of exceptions that the expression may throw.
CtClass[]	MethodCall.mayThrow()	Returns the list of exceptions that the expression may throw.
CtClass[]	NewArray.mayThrow()	Returns the list of exceptions that the expression may throw.
CtClass[]	NewExpr.mayThrow()	Returns the list of exceptions that the expression may throw.

Methods in javassist.expr with parameters of type CtClass

Modifier and Type	Method	Description
boolean	ExprEditor.doit(CtClass clazz, MethodInfo minfo)	Undocumented method.

Uses of CtClass in javassist.tools.reflect

Methods in javassist.tools.reflect with parameters of type CtClass

Modifier and Type	Method	Description
boolean	Reflection.makeReflective(CtClass clazz, CtClass metaobject, CtClass metaclass)	Produces a reflective class.

Uses of CtClass in javassist.util

Methods in javassist.util with parameters of type CtClass

Modifier and Type	Method	Description
static void	HotSwapAgent.redefine(Class<?>[] oldClasses, CtClass[] newClasses)	Redefines classes.
static void	HotSwapAgent.redefine(Class<?> oldClass, CtClass newClass)	Redefines a class.