Uses of Class
javassist.CtClass

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.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. 
 

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.
protected  CtClass CtMember.declaringClass
           
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
protected  CtClass ClassPool.createCtClass(java.lang.String classname, boolean useCache)
          Creates a CtClass object representing the specified class.
 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.
protected  CtClass ClassPool.get0(java.lang.String classname, boolean useCache)
           
 CtClass ClassPool.getAndRename(java.lang.String orgName, java.lang.String newName)
          Reads a class file and constructs a CtClass object with a new name.
protected  CtClass ClassPool.getCached(java.lang.String classname)
          Provide a hook so that subclasses can do their own caching of classes.
 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 CtClass.getDeclaringClass()
          If this class is a member class or interface of another class, then the class enclosing this class is returned.
 CtClass CtMember.getDeclaringClass()
          Returns the class that declares this member.
 CtClass CtField.getDeclaringClass()
          Returns the class declaring the field.
 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.
protected  CtClass ClassPool.removeCached(java.lang.String classname)
          Provide a hook so that subclasses can do their own caching of classes.
 

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.
protected  void ClassPool.cacheCtClass(java.lang.String classname, CtClass c, boolean dynamic)
          Provides a hook so that subclasses can do their own caching of classes.
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.
protected  void CodeConverter.doit(CtClass clazz, MethodInfo minfo, ConstPool cp)
          Performs code conversion.
 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 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)
          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 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
CtBehavior(CtClass clazz, MethodInfo minfo)
           
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.
CtConstructor(MethodInfo minfo, CtClass declaring)
           
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.
CtMember(CtClass clazz)
           
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)
          Prints all the methods declared in the given class.
static void FramePrinter.print(CtClass clazz, java.io.PrintStream stream)
          Prints all the methods declared in the given class.
 

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.compiler
 

Fields in javassist.compiler declared as CtClass
 CtClass MemberResolver.Method.declaring
           
protected  CtClass MemberCodeGen.thisClass
           
protected  CtClass TypeChecker.thisClass
           
 

Methods in javassist.compiler that return CtClass
static CtClass MemberResolver.getSuperclass(CtClass c)
           
 CtClass MemberCodeGen.getThisClass()
           
 CtClass MemberResolver.lookupClass(Declarator decl)
           
 CtClass MemberResolver.lookupClass(int type, int dim, java.lang.String classname)
           
 CtClass MemberResolver.lookupClass(java.lang.String name, boolean notCheckInner)
           
 CtClass MemberResolver.lookupClassByJvmName(java.lang.String jvmName)
           
 CtClass MemberResolver.lookupClassByName(ASTList name)
           
 CtClass[] MemberCodeGen.makeParamList(MethodDecl md)
           
 CtClass[] MemberCodeGen.makeThrowsList(MethodDecl md)
           
 

Methods in javassist.compiler with parameters of type CtClass
protected  void JvstCodeGen.atAssignParamList(CtClass[] params, Bytecode code)
           
 MemberResolver.Method TypeChecker.atMethodCallCore(CtClass targetClass, java.lang.String mname, ASTList args)
           
 void MemberCodeGen.atMethodCallCore(CtClass targetClass, java.lang.String mname, ASTList args, boolean isStatic, boolean isSpecial, int aload0pos, MemberResolver.Method found)
           
static int JvstCodeGen.compileParameterList(Bytecode code, CtClass[] params, int regno)
           
protected  void JvstTypeChecker.compileUnwrapValue(CtClass type)
           
protected  void JvstCodeGen.compileUnwrapValue(CtClass type, Bytecode code)
           
 void JvstCodeGen.doNumCast(CtClass type)
           
protected  java.lang.String MemberCodeGen.getAccessibleConstructor(java.lang.String desc, CtClass declClass, MethodInfo minfo)
           
protected  java.lang.String MemberCodeGen.getAccessiblePrivate(java.lang.String methodName, java.lang.String desc, java.lang.String newDesc, MethodInfo minfo, CtClass declClass)
           
 java.lang.String AccessorMaker.getConstructor(CtClass c, java.lang.String desc, MethodInfo orig)
           
static CtClass MemberResolver.getSuperclass(CtClass c)
           
 MemberResolver.Method MemberResolver.lookupMethod(CtClass clazz, CtClass currentClass, MethodInfo current, java.lang.String methodName, int[] argTypes, int[] argDims, java.lang.String[] argClassNames)
           
 int Javac.recordParams(CtClass[] params, boolean isStatic)
          Makes variables $0 (this), $1, $2, ..., and $args represent method parameters.
 int JvstCodeGen.recordParams(CtClass[] params, boolean isStatic, java.lang.String prefix, java.lang.String paramVarName, java.lang.String paramsName, boolean use0, int paramBase, java.lang.String target, SymbolTable tbl)
          Makes method parameters $0, $1, ..., $args, $$, and $class available.
 int JvstCodeGen.recordParams(CtClass[] params, boolean isStatic, java.lang.String prefix, java.lang.String paramVarName, java.lang.String paramsName, SymbolTable tbl)
          Makes method parameters $0, $1, ..., $args, $$, and $class available.
 int Javac.recordParams(java.lang.String target, CtClass[] params, boolean use0, int varNo, boolean isStatic)
          Makes variables $0, $1, $2, ..., and $args represent method parameters.
 int Javac.recordReturnType(CtClass type, boolean useResultVar)
          Prepares to use cast $r, $w, $_, and $type.
 int JvstCodeGen.recordReturnType(CtClass type, java.lang.String castName, java.lang.String resultName, SymbolTable tbl)
          Makes a cast to the return type ($r) available.
 void Javac.recordType(CtClass t)
          Prepares to use $type.
 void JvstCodeGen.recordType(CtClass t)
          Makes $type available.
 int Javac.recordVariable(CtClass type, java.lang.String name)
          Makes the given variable available.
 int JvstCodeGen.recordVariable(CtClass type, java.lang.String varName, SymbolTable tbl)
          Makes the given variable name available.
 void JvstCodeGen.setType(CtClass type)
           
 void JvstTypeChecker.setType(CtClass type)
           
 

Constructors in javassist.compiler with parameters of type CtClass
AccessorMaker(CtClass c)
           
Javac(Bytecode b, CtClass thisClass)
          Constructs a compiler.
Javac(CtClass thisClass)
          Constructs a compiler.
JvstCodeGen(Bytecode b, CtClass cc, ClassPool cp)
           
JvstTypeChecker(CtClass cc, ClassPool cp, JvstCodeGen gen)
           
MemberCodeGen(Bytecode b, CtClass cc, ClassPool cp)
           
MemberResolver.Method(CtClass c, MethodInfo i, int n)
           
TypeChecker(CtClass cc, ClassPool cp)
           
 

Uses of CtClass in javassist.convert
 

Fields in javassist.convert declared as CtClass
protected  CtClass TransformReadField.fieldClass
           
protected  CtClass[] TransformBefore.parameterTypes
           
 

Methods in javassist.convert with parameters of type CtClass
 void Transformer.initialize(ConstPool cp, CtClass clazz, MethodInfo minfo)
           
 void TransformAccessArrayField.initialize(ConstPool cp, CtClass clazz, MethodInfo minfo)
           
protected  void TransformBefore.makeCode(CtClass[] paramTypes, ConstPool cp)
           
abstract  int Transformer.transform(CtClass clazz, int pos, CodeIterator it, ConstPool cp)
           
 int TransformCall.transform(CtClass clazz, int pos, CodeIterator iterator, ConstPool cp)
          Modify INVOKEINTERFACE, INVOKESPECIAL, INVOKESTATIC and INVOKEVIRTUAL so that a different method is invoked.
 int TransformFieldAccess.transform(CtClass clazz, int pos, CodeIterator iterator, ConstPool cp)
          Modify GETFIELD, GETSTATIC, PUTFIELD, and PUTSTATIC so that a different field is accessed.
 int TransformAccessArrayField.transform(CtClass tclazz, int pos, CodeIterator iterator, ConstPool cp)
           
 int TransformNewClass.transform(CtClass clazz, int pos, CodeIterator iterator, ConstPool cp)
          Modifies a sequence of NEW classname DUP ...
 int TransformReadField.transform(CtClass tclazz, int pos, CodeIterator iterator, ConstPool cp)
           
 int TransformWriteField.transform(CtClass tclazz, int pos, CodeIterator iterator, ConstPool cp)
           
 int TransformNew.transform(CtClass clazz, int pos, CodeIterator iterator, ConstPool cp)
          Replace a sequence of NEW classname DUP ...
 

Uses of CtClass in javassist.expr
 

Methods in javassist.expr that return CtClass
 CtClass NewArray.getComponentType()
          Returns the type of array components.
protected  CtClass MethodCall.getCtClass()
          Returns the class of the target object, which the method is called on.
 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 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[] NewExpr.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[] 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[] FieldAccess.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[] Cast.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.
 

Methods in javassist.expr with parameters of type CtClass
 boolean ExprEditor.doit(CtClass clazz, MethodInfo minfo)
          Undocumented method.
 

Constructors in javassist.expr with parameters of type CtClass
Cast(int pos, CodeIterator i, CtClass declaring, MethodInfo m)
          Undocumented constructor.
ConstructorCall(int pos, CodeIterator i, CtClass decl, MethodInfo m)
          Undocumented constructor.
Expr(int pos, CodeIterator i, CtClass declaring, MethodInfo m)
          Undocumented constructor.
FieldAccess(int pos, CodeIterator i, CtClass declaring, MethodInfo m, int op)
           
Handler(ExceptionTable et, int nth, CodeIterator it, CtClass declaring, MethodInfo m)
          Undocumented constructor.
Instanceof(int pos, CodeIterator i, CtClass declaring, MethodInfo m)
          Undocumented constructor.
MethodCall(int pos, CodeIterator i, CtClass declaring, MethodInfo m)
          Undocumented constructor.
NewArray(int pos, CodeIterator i, CtClass declaring, MethodInfo m, int op)
           
NewExpr(int pos, CodeIterator i, CtClass declaring, MethodInfo m, java.lang.String type, int np)
          Undocumented constructor.
 

Uses of CtClass in javassist.scopedpool
 

Methods in javassist.scopedpool that return CtClass
protected  CtClass ScopedClassPool.getCached(java.lang.String classname)
          Get the cached class
protected  CtClass ScopedClassPool.getCachedLocally(java.lang.String classname)
          Whether the class is cached in this pooled
 CtClass ScopedClassPool.getLocally(java.lang.String classname)
          Get any local copy of the class
 

Methods in javassist.scopedpool with parameters of type CtClass
protected  void ScopedClassPool.cacheCtClass(java.lang.String classname, CtClass c, boolean dynamic)
          Cache a class
 void ScopedClassPool.lockInCache(CtClass c)
          Lock a class into the cache
 void ScopedClassPool.soften(CtClass clazz)
          Soften a class
 java.lang.Class ScopedClassPool.toClass(CtClass ct, java.lang.ClassLoader loader, java.security.ProtectionDomain domain)
          Convert a javassist class to a java class
 

Uses of CtClass in javassist.tools.reflect
 

Fields in javassist.tools.reflect declared as CtClass
protected  CtClass[] Reflection.readParam
           
 

Methods in javassist.tools.reflect with parameters of type CtClass
 boolean Reflection.makeReflective(CtClass clazz, CtClass metaobject, CtClass metaclass)
          Produces a reflective class.
 



Copyright © 2011. All Rights Reserved.