|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use CtClass | |
---|---|
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. |
Uses of CtClass in javassist |
---|
Subclasses of CtClass in javassist | |
---|---|
class |
CtPrimitiveType
An instance of CtPrimitiveType represents a primitive type. |
Fields in javassist declared as CtClass | |
---|---|
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 | |
---|---|
CtClass |
ClassPool.get(java.lang.String classname)
Reads a class file from the source and returns a reference to the CtClass
object representing that class file. |
CtClass[] |
ClassPool.get(java.lang.String[] classnames)
Reads class files from the source and returns an array of CtClass
objects representing those class files. |
CtClass |
ClassPool.getAndRename(java.lang.String orgName,
java.lang.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(java.lang.String classname)
Returns a CtClass object with the given name. |
CtClass |
CtMember.getDeclaringClass()
Returns the class that declares this member. |
CtClass |
CtField.getDeclaringClass()
Returns the class declaring the field. |
CtClass |
CtClass.getDeclaringClass()
If this class is a member class or interface of another class, then the class enclosing this class is returned. |
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[] |
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.makeClass(java.io.InputStream classfile)
Creates a new class (or interface) from the given class file. |
CtClass |
ClassPool.makeClass(java.io.InputStream classfile,
boolean ifNotFrozen)
Creates a new class (or interface) from the given class file. |
CtClass |
ClassPool.makeClass(java.lang.String classname)
Creates a new public class. |
CtClass |
ClassPool.makeClass(java.lang.String classname,
CtClass superclass)
Creates a new public class. |
CtClass |
ClassPool.makeClassIfNew(java.io.InputStream classfile)
Creates a new class (or interface) from the given class file. |
CtClass |
ClassPool.makeInterface(java.lang.String name)
Creates a new public interface. |
CtClass |
ClassPool.makeInterface(java.lang.String name,
CtClass superclass)
Creates a new public interface. |
CtClass |
CtClass.makeNestedClass(java.lang.String name,
boolean isStatic)
Makes a new public nested class. |
Methods in javassist with parameters of type CtClass | |
---|---|
static CtMethod |
CtNewMethod.abstractMethod(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public abstract method. |
static CtMethod |
CtNewMethod.abstractMethod(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public abstract method. |
static CtMethod |
CtNewMethod.abstractMethod(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public abstract method. |
void |
CtBehavior.addCatch(java.lang.String src,
CtClass exceptionType)
Adds a catch clause that handles an exception thrown in the body. |
void |
CtBehavior.addCatch(java.lang.String src,
CtClass exceptionType,
java.lang.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(java.lang.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,
java.lang.String methodName)
Makes an initializer calling a static method. |
static CtField.Initializer |
CtField.Initializer.byCall(CtClass methodClass,
java.lang.String methodName,
java.lang.String[] stringParams)
Makes an initializer calling a static method. |
static CtField.Initializer |
CtField.Initializer.byCallWithParams(CtClass methodClass,
java.lang.String methodName)
Makes an initializer calling a static method. |
static CtField.Initializer |
CtField.Initializer.byCallWithParams(CtClass methodClass,
java.lang.String methodName,
java.lang.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,
java.lang.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,
java.lang.String[] stringParams)
Makes an initializer creating a new object. |
static CtConstructor |
CtNewConstructor.copy(CtConstructor c,
CtClass declaring,
ClassMap map)
Creats a copy of a constructor. |
static CtMethod |
CtNewMethod.copy(CtMethod src,
CtClass declaring,
ClassMap map)
Creates a copy of a method. |
static CtMethod |
CtNewMethod.copy(CtMethod src,
java.lang.String name,
CtClass declaring,
ClassMap map)
Creates a copy of a method with a new name. |
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(java.lang.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. |
static CtConstructor |
CtNewConstructor.make(CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
static CtConstructor |
CtNewConstructor.make(CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
static CtConstructor |
CtNewConstructor.make(CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
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,
int howto,
CtMethod body,
CtMethod.ConstParameter cparam,
CtClass declaring)
Creates a public 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,
java.lang.String body,
CtClass declaring)
Creates a public constructor. |
static CtConstructor |
CtNewConstructor.make(CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a public constructor. |
static CtConstructor |
CtNewConstructor.make(CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a public constructor. |
static CtMethod |
CtNewMethod.make(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a public (non-static) method. |
static CtMethod |
CtNewMethod.make(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a public (non-static) method. |
static CtMethod |
CtNewMethod.make(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a public (non-static) method. |
static CtMethod |
CtNewMethod.make(int modifiers,
CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a method. |
static CtMethod |
CtNewMethod.make(int modifiers,
CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a method. |
static CtMethod |
CtNewMethod.make(int modifiers,
CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass[] exceptions,
java.lang.String body,
CtClass declaring)
Creates a method. |
static CtMethod |
CtMethod.make(MethodInfo minfo,
CtClass declaring)
Creates a method from a MethodInfo object. |
static CtMethod |
CtNewMethod.make(java.lang.String src,
CtClass declaring)
Compiles the given source code and creates a method. |
static CtConstructor |
CtNewConstructor.make(java.lang.String src,
CtClass declaring)
Compiles the given source code and creates a constructor. |
static CtMethod |
CtMethod.make(java.lang.String src,
CtClass declaring)
Compiles the given source code and creates a method. |
static CtField |
CtField.make(java.lang.String src,
CtClass declaring)
Compiles the given source code and creates a field. |
static CtMethod |
CtNewMethod.make(java.lang.String src,
CtClass declaring,
java.lang.String delegateObj,
java.lang.String delegateMethod)
Compiles the given source code and creates a method. |
CtClass |
ClassPool.makeClass(java.lang.String classname,
CtClass superclass)
Creates a new public class. |
CtClass |
ClassPool.makeInterface(java.lang.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,
java.lang.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,
java.lang.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,
java.lang.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,
java.lang.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. |
static CtConstructor |
CtNewConstructor.skeleton(CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
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 . |
java.lang.Class |
ClassPool.toClass(CtClass clazz)
Converts the given class to a java.lang.Class object. |
java.lang.Class |
ClassPool.toClass(CtClass ct,
java.lang.ClassLoader loader)
Deprecated. Replaced by ClassPool.toClass(CtClass,ClassLoader,ProtectionDomain) .
A subclass of ClassPool that has been
overriding this method should be modified. It should override
ClassPool.toClass(CtClass,ClassLoader,ProtectionDomain) . |
java.lang.Class |
ClassPool.toClass(CtClass ct,
java.lang.ClassLoader loader,
java.security.ProtectionDomain domain)
Converts the class to a java.lang.Class object. |
CtMethod |
CtConstructor.toMethod(java.lang.String name,
CtClass declaring)
Makes a copy of this constructor and converts it into a method. |
CtMethod |
CtConstructor.toMethod(java.lang.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,
java.lang.String mname,
CtClass[] parameterTypes,
CtClass[] exceptionTypes,
CtMethod body,
CtMethod.ConstParameter constParam,
CtClass declaring)
Creates a wrapped method. |
static CtMethod |
CtNewMethod.wrapped(CtClass returnType,
java.lang.String mname,
CtClass[] parameterTypes,
CtClass[] exceptionTypes,
CtMethod body,
CtMethod.ConstParameter constParam,
CtClass declaring)
Creates a wrapped method. |
static CtMethod |
CtNewMethod.wrapped(CtClass returnType,
java.lang.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 | |
---|---|
CtConstructor(CtClass[] parameters,
CtClass declaring)
Creates a constructor with no constructor body. |
|
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,
java.lang.String name,
CtClass declaring)
Creates a CtField object. |
|
CtField(CtField src,
CtClass declaring)
Creates a copy of the given field. |
|
CtMethod(CtClass returnType,
java.lang.String mname,
CtClass[] parameters,
CtClass declaring)
Creates a public abstract method. |
|
CtMethod(CtClass returnType,
java.lang.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 | |
---|---|
static CtClass |
ConstPool.THIS
Represents the class using this constant pool table. |
static CtClass |
Bytecode.THIS
Represents the CtClass file using the
constant pool table given to this Bytecode object. |
Methods in javassist.bytecode that return CtClass | |
---|---|
CtClass |
SignatureAttribute.BaseType.getCtlass()
Returns the CtClass representing this
primitive type. |
static CtClass[] |
Descriptor.getParameterTypes(java.lang.String desc,
ClassPool cp)
Returns the CtClass objects representing the parameter
types specified by the given descriptor. |
static CtClass |
Descriptor.getReturnType(java.lang.String desc,
ClassPool cp)
Returns the CtClass object representing the return
type specified by the given descriptor. |
static CtClass |
Descriptor.toCtClass(java.lang.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 | |
---|---|
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,
java.lang.String name,
java.lang.String type)
Appends GETFIELD. |
void |
Bytecode.addGetstatic(CtClass c,
java.lang.String name,
java.lang.String type)
Appends GETSTATIC. |
void |
Bytecode.addInvokeinterface(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes,
int count)
Appends INVOKEINTERFACE. |
void |
Bytecode.addInvokeinterface(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes,
int count)
Appends INVOKEINTERFACE. |
void |
Bytecode.addInvokeinterface(CtClass clazz,
java.lang.String name,
java.lang.String desc,
int count)
Appends INVOKEINTERFACE. |
void |
Bytecode.addInvokespecial(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes)
Appends INVOKESPECIAL. |
void |
Bytecode.addInvokespecial(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes)
Appends INVOKESPECIAL. |
void |
Bytecode.addInvokespecial(CtClass clazz,
java.lang.String name,
java.lang.String desc)
Appends INVOKESPECIAL. |
void |
Bytecode.addInvokestatic(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes)
Appends INVOKESTATIC. |
void |
Bytecode.addInvokestatic(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes)
Appends INVOKESTATIC. |
void |
Bytecode.addInvokestatic(CtClass clazz,
java.lang.String name,
java.lang.String desc)
Appends INVOKESTATIC. |
void |
Bytecode.addInvokevirtual(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes)
Appends INVOKEVIRTUAL. |
void |
Bytecode.addInvokevirtual(CtClass clazz,
java.lang.String name,
CtClass returnType,
CtClass[] paramTypes)
Appends INVOKEVIRTUAL. |
void |
Bytecode.addInvokevirtual(CtClass clazz,
java.lang.String name,
java.lang.String desc)
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,
java.lang.String name,
java.lang.String desc)
Appends PUTFIELD. |
void |
Bytecode.addPutstatic(CtClass c,
java.lang.String name,
java.lang.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 java.lang.String |
Descriptor.appendParameter(CtClass type,
java.lang.String descriptor)
Appends a parameter type to the parameter list represented by the given descriptor. |
static java.lang.String |
Descriptor.insertParameter(CtClass type,
java.lang.String descriptor)
Inserts a parameter type at the beginning of the parameter list represented by the given descriptor. |
static java.lang.String |
Descriptor.of(CtClass type)
Returns the descriptor representing the given type. |
static java.lang.String |
Descriptor.ofConstructor(CtClass[] paramTypes)
Returns the descriptor representing a constructor receiving the given parameter types. |
static java.lang.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 java.lang.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 java.lang.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 java.lang.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 | |
---|---|
CtClass |
Type.getCtClass()
Returns the class this type represents. |
CtClass |
MultiType.getCtClass()
Gets the class that corresponds with this type. |
CtClass |
MultiArrayType.getCtClass()
|
Methods in javassist.bytecode.analysis with parameters of type CtClass | |
---|---|
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)
|
static void |
FramePrinter.print(CtClass clazz,
java.io.PrintStream stream)
|
Uses of CtClass in javassist.bytecode.annotation |
---|
Methods in javassist.bytecode.annotation with parameters of type CtClass | |
---|---|
static MemberValue |
Annotation.createMemberValue(ConstPool cp,
CtClass type)
Makes an instance of MemberValue . |
Constructors in javassist.bytecode.annotation with parameters of type CtClass | |
---|---|
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 | |
---|---|
CtClass |
NewArray.getComponentType()
Returns the type of array components. |
CtClass |
Expr.getEnclosingClass()
Returns the class that declares the method enclosing this expression. |
CtClass |
Instanceof.getType()
Returns the CtClass object representing
the type name on the right hand side
of the instanceof operator. |
CtClass |
Handler.getType()
Returns the type handled by the catch clause. |
CtClass |
Cast.getType()
Returns the CtClass object representing
the type specified by the cast. |
CtClass[] |
NewExpr.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[] |
MethodCall.mayThrow()
Returns the list of exceptions that the expression may throw. |
CtClass[] |
Instanceof.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[] |
FieldAccess.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[] |
Cast.mayThrow()
Returns the list of exceptions that the expression may throw. |
Methods in javassist.expr with parameters of type CtClass | |
---|---|
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 | |
---|---|
boolean |
Reflection.makeReflective(CtClass clazz,
CtClass metaobject,
CtClass metaclass)
Produces a reflective class. |
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |