|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use CannotCompileException | |
---|---|
javassist | The Javassist Core API. |
javassist.bytecode | Bytecode-level API. |
javassist.expr | This package contains the classes for modifying a method body. |
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.proxy | Dynamic proxy (similar to Enhancer of cglib). |
Uses of CannotCompileException in javassist |
---|
Methods in javassist that throw CannotCompileException | |
---|---|
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.addConstructor(CtConstructor c)
Adds a constructor. |
void |
CtClass.addField(CtField f)
Adds a field. |
void |
CtClass.addField(CtField f,
CtField.Initializer init)
Adds a field with an initial value. |
void |
CtClass.addField(CtField f,
java.lang.String init)
Adds a field with an initial value. |
void |
CtBehavior.addLocalVariable(java.lang.String name,
CtClass type)
Declares a new local variable. |
void |
CtClass.addMethod(CtMethod m)
Adds a method. |
void |
CtBehavior.addParameter(CtClass type)
Appends a new parameter, which becomes the last parameter. |
void |
Loader.addTranslator(ClassPool cp,
Translator t)
Adds a translator, which is called whenever a class is loaded. |
boolean |
CtConstructor.callsSuper()
Returns true if this constructor calls a constructor of the super class. |
static CtConstructor |
CtNewConstructor.copy(CtConstructor c,
CtClass declaring,
ClassMap map)
Creates 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. |
static CtMethod |
CtNewMethod.getter(java.lang.String methodName,
CtField field)
Creates a public getter method. |
void |
CtBehavior.insertAfter(java.lang.String src)
Inserts bytecode at the end of the body. |
void |
CtBehavior.insertAfter(java.lang.String src,
boolean asFinally)
Inserts bytecode at the end of the body. |
void |
CodeConverter.insertAfterMethod(CtMethod origMethod,
CtMethod afterMethod)
Inserts a call to another method after an existing method call. |
int |
CtBehavior.insertAt(int lineNum,
boolean modify,
java.lang.String src)
Inserts bytecode at the specified line in the body. |
int |
CtBehavior.insertAt(int lineNum,
java.lang.String src)
Inserts bytecode at the specified line in the body. |
void |
CtBehavior.insertBefore(java.lang.String src)
Inserts bytecode at the beginning of the body. |
void |
CtConstructor.insertBeforeBody(java.lang.String src)
Inserts bytecode just after another constructor in the super class or this class is called. |
void |
CodeConverter.insertBeforeMethod(CtMethod origMethod,
CtMethod beforeMethod)
Insert a call to another method before an existing method call. |
void |
CtBehavior.insertParameter(CtClass type)
Inserts a new parameter, which becomes the first parameter. |
void |
CtBehavior.instrument(CodeConverter converter)
Modifies the method/constructor body. |
void |
CtClass.instrument(CodeConverter converter)
Applies the given converter to all methods and constructors declared in the class. |
void |
CtBehavior.instrument(ExprEditor editor)
Modifies the method/constructor body. |
void |
CtClass.instrument(ExprEditor editor)
Modifies the bodies of all methods and constructors declared in the 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,
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(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 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 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. |
CtConstructor |
CtClass.makeClassInitializer()
Makes an empty class initializer (static constructor). |
void |
Translator.onLoad(ClassPool pool,
java.lang.String classname)
Is invoked by a Loader for notifying that
a class is loaded. |
void |
CodeConverter.redirectMethodCall(CtMethod origMethod,
CtMethod substMethod)
Modify method invocations in a method body so that a different method will be invoked. |
void |
CodeConverter.redirectMethodCall(java.lang.String oldMethodName,
CtMethod newMethod)
Correct invocations to a method that has been renamed. |
void |
CtConstructor.setBody(CtConstructor src,
ClassMap map)
Copies a constructor body from another constructor. |
void |
CtMethod.setBody(CtMethod src,
ClassMap map)
Copies a method body from another method. |
void |
CtBehavior.setBody(java.lang.String src)
Sets a method/constructor body. |
void |
CtConstructor.setBody(java.lang.String src)
Sets a constructor body. |
void |
CtBehavior.setBody(java.lang.String src,
java.lang.String delegateObj,
java.lang.String delegateMethod)
Sets a method/constructor body. |
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. |
static CtMethod |
CtNewMethod.setter(java.lang.String methodName,
CtField field)
Creates a public setter method. |
void |
CtMethod.setWrappedBody(CtMethod mbody,
CtMethod.ConstParameter constParam)
Replace a method body with a new method body wrapping the given method. |
static CtConstructor |
CtNewConstructor.skeleton(CtClass[] parameters,
CtClass[] exceptions,
CtClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
void |
Translator.start(ClassPool pool)
Is invoked by a Loader for initialization
when the object is attached to the Loader object. |
byte[] |
CtClass.toBytecode()
Converts this class to a class file. |
void |
CtClass.toBytecode(java.io.DataOutputStream out)
Converts this class to a class file. |
java.lang.Class |
CtClass.toClass()
Converts this class to a java.lang.Class object. |
java.lang.Class |
CtClass.toClass(java.lang.ClassLoader loader)
Deprecated. Replaced by CtClass.toClass(ClassLoader,ProtectionDomain) |
java.lang.Class |
CtClass.toClass(java.lang.ClassLoader loader,
java.security.ProtectionDomain domain)
Converts this class to a java.lang.Class object. |
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. |
void |
CtBehavior.useCflow(java.lang.String name)
Declares to use $cflow for this method/constructor. |
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. |
void |
CtClass.writeFile()
Writes a class file represented by this CtClass
object in the current directory. |
void |
CtClass.writeFile(java.lang.String directoryName)
Writes a class file represented by this CtClass
object on a local disk. |
Constructors in javassist that throw CannotCompileException | |
---|---|
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(CtMethod src,
CtClass declaring,
ClassMap map)
Creates a copy of a CtMethod object. |
Uses of CannotCompileException in javassist.bytecode |
---|
Subclasses of CannotCompileException in javassist.bytecode | |
---|---|
class |
DuplicateMemberException
An exception thrown when adding a duplicate member is requested. |
Methods in javassist.bytecode that throw CannotCompileException | |
---|---|
void |
StackMap.removeNew(int where)
Undocumented method. |
void |
StackMapTable.removeNew(int where)
Undocumented method. |
void |
ClassFile.setSuperclass(java.lang.String superclass)
Sets the super class. |
Uses of CannotCompileException in javassist.expr |
---|
Methods in javassist.expr that throw CannotCompileException | |
---|---|
boolean |
ExprEditor.doit(CtClass clazz,
MethodInfo minfo)
Undocumented method. |
void |
ExprEditor.edit(Cast c)
Edits an expression for explicit type casting (overridable). |
void |
ExprEditor.edit(ConstructorCall c)
Edits a constructor call (overridable). |
void |
ExprEditor.edit(FieldAccess f)
Edits a field-access expression (overridable). |
void |
ExprEditor.edit(Handler h)
Edits a catch clause (overridable). |
void |
ExprEditor.edit(Instanceof i)
Edits an instanceof expression (overridable). |
void |
ExprEditor.edit(MethodCall m)
Edits a method call (overridable). |
void |
ExprEditor.edit(NewArray a)
Edits an expression for array creation (overridable). |
void |
ExprEditor.edit(NewExpr e)
Edits a new expression (overridable). |
void |
Handler.insertBefore(java.lang.String src)
Inserts bytecode at the beginning of the catch clause. |
void |
Cast.replace(java.lang.String statement)
Replaces the explicit cast operator with the bytecode derived from the given source text. |
void |
NewArray.replace(java.lang.String statement)
Replaces the array creation with the bytecode derived from the given source text. |
void |
Handler.replace(java.lang.String statement)
This method has not been implemented yet. |
void |
FieldAccess.replace(java.lang.String statement)
Replaces the method call with the bytecode derived from the given source text. |
void |
NewExpr.replace(java.lang.String statement)
Replaces the new expression with the bytecode derived from the given source text. |
void |
Instanceof.replace(java.lang.String statement)
Replaces the instanceof operator with the bytecode derived from the given source text. |
abstract void |
Expr.replace(java.lang.String statement)
Replaces this expression with the bytecode derived from the given source text. |
void |
MethodCall.replace(java.lang.String statement)
Replaces the method call with the bytecode derived from the given source text. |
void |
Expr.replace(java.lang.String statement,
ExprEditor recursive)
Replaces this expression with the bytecode derived from the given source text and ExprEditor . |
Uses of CannotCompileException in javassist.tools.reflect |
---|
Subclasses of CannotCompileException in javassist.tools.reflect | |
---|---|
class |
CannotReflectException
Thrown by makeReflective() in Reflection
when there is an attempt to reflect
a class that is either an interface or a subclass of
either ClassMetaobject or Metaobject. |
Methods in javassist.tools.reflect that throw CannotCompileException | |
---|---|
boolean |
Reflection.makeReflective(java.lang.Class clazz,
java.lang.Class metaobject,
java.lang.Class metaclass)
Produces a reflective class. |
boolean |
Reflection.makeReflective(CtClass clazz,
CtClass metaobject,
CtClass metaclass)
Produces a reflective class. |
boolean |
Reflection.makeReflective(java.lang.String classname,
java.lang.String metaobject,
java.lang.String metaclass)
Produces a reflective class. |
boolean |
Loader.makeReflective(java.lang.String clazz,
java.lang.String metaobject,
java.lang.String metaclass)
Produces a reflective class. |
void |
Reflection.onLoad(ClassPool pool,
java.lang.String classname)
Inserts hooks for intercepting accesses to the fields declared in reflective classes. |
Constructors in javassist.tools.reflect that throw CannotCompileException | |
---|---|
Loader()
Constructs a new class loader. |
Uses of CannotCompileException in javassist.tools.rmi |
---|
Methods in javassist.tools.rmi that throw CannotCompileException | |
---|---|
int |
AppletServer.exportObject(java.lang.String name,
java.lang.Object obj)
Exports an object. |
boolean |
StubGenerator.makeProxyClass(java.lang.Class clazz)
Makes a proxy class. |
Constructors in javassist.tools.rmi that throw CannotCompileException | |
---|---|
AppletServer(int port)
Constructs a web server. |
|
AppletServer(int port,
ClassPool src)
Constructs a web server. |
|
AppletServer(java.lang.String port)
Constructs a web server. |
Uses of CannotCompileException in javassist.tools.web |
---|
Methods in javassist.tools.web that throw CannotCompileException | |
---|---|
void |
Webserver.addTranslator(ClassPool cp,
Translator t)
Adds a translator, which is called whenever a client requests a class file. |
Uses of CannotCompileException in javassist.util.proxy |
---|
Methods in javassist.util.proxy that throw CannotCompileException | |
---|---|
static java.lang.Class |
FactoryHelper.toClass(ClassFile cf,
java.lang.ClassLoader loader)
Loads a class file by a given class loader. |
static java.lang.Class |
FactoryHelper.toClass(ClassFile cf,
java.lang.ClassLoader loader,
java.security.ProtectionDomain domain)
Loads a class file by a given class loader. |
static void |
FactoryHelper.writeFile(ClassFile cf,
java.lang.String directoryName)
Writes a class file. |
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |