|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use CannotCompileException | |
---|---|
classUtils.javassist | |
classUtils.javassist.bytecode | Bytecode-level API. |
classUtils.javassist.convert | |
classUtils.javassist.expr | This package contains the classes for modifying a method body. |
classUtils.javassist.preproc | A sample preprocessor. |
classUtils.javassist.reflect | Runtime Reflection. |
classUtils.javassist.rmi | Remote Method Invocation. |
classUtils.javassist.sample.evolve | |
classUtils.javassist.sample.rmi | |
classUtils.javassist.sample.vector | |
classUtils.putils |
Uses of CannotCompileException in classUtils.javassist |
---|
Methods in classUtils.javassist that throw CannotCompileException | |
---|---|
void |
CtConstructor.addCatch(java.lang.String src,
CompileTimeClass exceptionType)
Adds a catch clause that handles an exception thrown in the constructor body. |
void |
CtMethod.addCatch(java.lang.String src,
CompileTimeClass exceptionType)
Adds a catch clause that handles an exception thrown in the method body. |
void |
CtBehavior.addCatch(java.lang.String src,
CompileTimeClass exceptionType)
Adds a catch clause that handles an exception thrown in the body. |
void |
CtBehavior.addCatch(java.lang.String src,
CompileTimeClass exceptionType,
java.lang.String exceptionName)
Adds a catch clause that handles an exception thrown in the body. |
void |
CompileTimeClass.addConstructor(CtConstructor c)
Adds a constructor. |
void |
CompileTimeClassType.addConstructor(CtConstructor c)
|
void |
CompileTimeNewClass.addConstructor(CtConstructor c)
|
void |
CompileTimeClass.addField(CtField f)
Adds a field. |
void |
CompileTimeClass.addField(CtField f,
CtField.Initializer init)
Adds a field with an initial value. |
void |
CompileTimeClassType.addField(CtField f,
CtField.Initializer init)
|
void |
CompileTimeClass.addField(CtField f,
java.lang.String init)
Adds a field with an initial value. |
void |
CompileTimeClassType.addField(CtField f,
java.lang.String init)
|
void |
CompileTimeClass.addMethod(CtMethod m)
Adds a method. |
void |
CompileTimeClassType.addMethod(CtMethod m)
|
static CtConstructor |
CtNewConstructor.copy(CtConstructor c,
CompileTimeClass declaring,
ClassMap map)
Creats a copy of a constructor. |
static CtMethod |
CtNewMethod.copy(CtMethod src,
CompileTimeClass declaring,
ClassMap map)
Creates a copy of a method. |
static CtMethod |
CtNewMethod.copy(CtMethod src,
java.lang.String name,
CompileTimeClass declaring,
ClassMap map)
Creates a copy of a method with a new name. |
void |
ClassPool.debugWriteFile(java.lang.String classname)
Writes a class file specified with classname in the
current directory. |
void |
ClassPool.debugWriteFile(java.lang.String classname,
java.lang.String directoryName)
Writes a class file specified with classname . |
static CtConstructor |
CtNewConstructor.defaultConstructor(CompileTimeClass declaring)
Creates a default (public) constructor. |
static CtMethod |
CtNewMethod.delegator(CtMethod delegate,
CompileTimeClass 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 |
CompileTimeNewClass.inheritAllConstructors()
Adds constructors inhrited from the super class. |
void |
CtConstructor.insertAfter(java.lang.String src)
Inserts bytecode affineTransform the end of the constructor body. |
void |
CtMethod.insertAfter(java.lang.String src)
Inserts bytecode affineTransform the end of the method body. |
void |
CtBehavior.insertAfter(java.lang.String src)
Inserts bytecode affineTransform the end of the body. |
void |
CtConstructor.insertAfter(java.lang.String src,
boolean asFinally)
Inserts bytecode affineTransform the end of the constructor body. |
void |
CtMethod.insertAfter(java.lang.String src,
boolean asFinally)
Inserts bytecode affineTransform the end of the method body. |
void |
CtBehavior.insertAfter(java.lang.String src,
boolean asFinally)
Inserts bytecode affineTransform the end of the body. |
void |
CodeConverter.insertAfterMethod(CtMethod origMethod,
CtMethod afterMethod)
Inserts a call to another method after an existing method call. |
void |
CtConstructor.insertBefore(java.lang.String src)
Inserts bytecode affineTransform the beginning of the constructor body. |
void |
CtMethod.insertBefore(java.lang.String src)
Inserts bytecode affineTransform the beginning of the method body. |
void |
CtBehavior.insertBefore(java.lang.String src)
Inserts bytecode affineTransform 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 |
CompileTimeClass.instrument(CodeConverter converter)
Applies the given converter to all methods and constructors declared in the class. |
void |
CtConstructor.instrument(CodeConverter converter)
Modifies the constructor body. |
void |
CompileTimeClassType.instrument(CodeConverter converter)
|
void |
CtMethod.instrument(CodeConverter converter)
Modifies the method body. |
void |
CtBehavior.instrument(CodeConverter converter)
Modifies the member body. |
void |
CompileTimeClass.instrument(ExprEditor editor)
Modifies the bodies of all methods and constructors declared in the class. |
void |
CtConstructor.instrument(ExprEditor editor)
Modifies the constructor body. |
void |
CompileTimeClassType.instrument(ExprEditor editor)
|
void |
CtMethod.instrument(ExprEditor editor)
Modifies the method body. |
void |
CtBehavior.instrument(ExprEditor editor)
Modifies the member body. |
static CtConstructor |
CtNewConstructor.make(CompileTimeClass[] parameters,
CompileTimeClass[] exceptions,
CompileTimeClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
static CtConstructor |
CtNewConstructor.make(CompileTimeClass[] parameters,
CompileTimeClass[] exceptions,
int howto,
CtMethod body,
CtMethod.ConstParameter cparam,
CompileTimeClass declaring)
Creates a public constructor. |
static CtConstructor |
CtNewConstructor.make(CompileTimeClass[] parameters,
CompileTimeClass[] exceptions,
java.lang.String body,
CompileTimeClass declaring)
Creates a public constructor. |
static CtMethod |
CtNewMethod.make(CompileTimeClass returnType,
java.lang.String mname,
CompileTimeClass[] parameters,
CompileTimeClass[] exceptions,
java.lang.String body,
CompileTimeClass declaring)
Creates a public method. |
static CtMethod |
CtNewMethod.make(java.lang.String src,
CompileTimeClass declaring)
Compiles the given source code and creates a method. |
static CtConstructor |
CtNewConstructor.make(java.lang.String src,
CompileTimeClass declaring)
Compiles the given source code and creates a constructor. |
static CtField |
CtField.make(java.lang.String src,
CompileTimeClass declaring)
Compiles the given source code and creates a field. |
static CtMethod |
CtNewMethod.make(java.lang.String src,
CompileTimeClass declaring,
java.lang.String delegateObj,
java.lang.String delegateMethod)
Compiles the given source code and creates a method. |
CtConstructor |
CompileTimeClass.makeClassInitializer()
Makes a class initializer (static constructor). |
CtConstructor |
CompileTimeClassType.makeClassInitializer()
|
void |
Translator.onWrite(ClassPool pool,
java.lang.String classname)
Is invoked by a ClassPool for notifying that
a class is written out to an output stream. |
void |
CodeConverter.redirectMethodCall(CtMethod origMethod,
CtMethod substMethod)
Modify method invocations in a method body so that a different method is invoked. |
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 |
CtConstructor.setBody(java.lang.String src)
Sets a constructor body. |
void |
CtMethod.setBody(java.lang.String src)
Sets a method body. |
void |
CtBehavior.setBody(java.lang.String src)
Sets a member body. |
static void |
SerialVersionUID.setSerialVersionUID(CompileTimeClass clazz)
Adds serialVersionUID if one does not already exist. |
void |
CompileTimeClass.setSuperclass(CompileTimeClass clazz)
Changes a super class. |
void |
CompileTimeClassType.setSuperclass(CompileTimeClass clazz)
|
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(CompileTimeClass[] parameters,
CompileTimeClass[] exceptions,
CompileTimeClass declaring)
Creates a public constructor that only calls a constructor in the super class. |
void |
Translator.start(ClassPool pool)
Is invoked by a ClassPool for initialization
when the object is attached to a ClassPool object. |
byte[] |
CompileTimeClass.toBytecode()
Converts this class to a class file. |
java.lang.Class |
CompileTimeClass.toClass()
Converts this class to a java.lang.Class object. |
void |
CtConstructor.useCflow(java.lang.String name)
Declares to use $cflow for this constructor. |
void |
CtMethod.useCflow(java.lang.String name)
Declares to use $cflow for this method. |
void |
CtBehavior.useCflow(java.lang.String name)
Declares to use $cflow for this member;
If $cflow is used, the class files modified
with Javassist requires a support class
javassist.runtime.Cflow affineTransform runtime
(other Javassist classes are not required affineTransform runtime). |
static CtMethod |
CtNewMethod.wrapped(CompileTimeClass returnType,
java.lang.String mname,
CompileTimeClass[] parameterTypes,
CompileTimeClass[] exceptionTypes,
CtMethod body,
CtMethod.ConstParameter constParam,
CompileTimeClass declaring)
Creates a wrapped method. |
byte[] |
ClassPool.write(java.lang.String classname)
Returns a byte array representing the class file. |
void |
ClassPool.write(java.lang.String classname,
java.io.DataOutputStream out)
Writes a class file specified by classname to a given
output stream. |
java.lang.Class |
ClassPool.writeAsClass(java.lang.String classname)
Returns a java.lang.Class object. |
void |
CompileTimeClass.writeFile()
Writes a class file represented by this CtClass
object in the current directory. |
void |
ClassPool.writeFile(java.lang.String classname)
Writes a class file specified with classname in the
current directory. |
void |
ClassPool.writeFile(java.lang.String classname,
java.lang.String directoryName)
Writes a class file specified with classname on a local
disk. |
Constructors in classUtils.javassist that throw CannotCompileException | |
---|---|
CtConstructor(CtConstructor src,
CompileTimeClass declaring,
ClassMap map)
Creates a copy of a CtConstructor object. |
|
CtField(CompileTimeClass type,
java.lang.String name,
CompileTimeClass declaring)
Creates a CtField object. |
|
CtField(CtField src,
CompileTimeClass declaring)
Creates a copy of the given field. |
|
CtMethod(CtMethod src,
CompileTimeClass declaring,
ClassMap map)
Creates a copy of a CtMethod object. |
Uses of CannotCompileException in classUtils.javassist.bytecode |
---|
Methods in classUtils.javassist.bytecode that throw CannotCompileException | |
---|---|
void |
JAClassFile.setSuperclass(java.lang.String superclass)
Sets the super class. |
Uses of CannotCompileException in classUtils.javassist.convert |
---|
Methods in classUtils.javassist.convert that throw CannotCompileException | |
---|---|
int |
TransformNew.transform(CompileTimeClass clazz,
int pos,
CodeIterator iterator,
ConstPool cp)
Replace a sequence of NEW classname DUP ... |
abstract int |
Transformer.transform(CompileTimeClass clazz,
int pos,
CodeIterator it,
ConstPool cp)
|
Uses of CannotCompileException in classUtils.javassist.expr |
---|
Methods in classUtils.javassist.expr that throw CannotCompileException | |
---|---|
boolean |
ExprEditor.doit(CompileTimeClass clazz,
MethodInfo minfo)
Undocumented method. |
void |
ExprEditor.edit(Cast c)
Edits an expression for explicit type casting (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(NewExpr e)
Edits a new expression (overridable). |
void |
Handler.insertBefore(java.lang.String src)
Inserts bytecode affineTransform the beginning of the catch clause. |
void |
NewExpr.replace(java.lang.String statement)
Replaces the new expression with the bytecode derived from the given source text. |
void |
Handler.replace(java.lang.String statement)
This method has not been implemented yet. |
void |
Cast.replace(java.lang.String statement)
Replaces the explicit cast operator 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 |
FieldAccess.replace(java.lang.String statement)
Replaces the method call 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. |
Uses of CannotCompileException in classUtils.javassist.preproc |
---|
Methods in classUtils.javassist.preproc that throw CannotCompileException | |
---|---|
CompileTimeClass[] |
Assistant.assist(ClassPool cp,
java.lang.String importname,
java.lang.String[] args)
Is called when the Javassist preprocessor encounters an import declaration annotated with the "by" keyword. |
void |
Compiler.process()
Starts preprocessing. |
Constructors in classUtils.javassist.preproc that throw CannotCompileException | |
---|---|
Compiler(java.lang.String inputname)
Constructs a Compiler with a source file. |
Uses of CannotCompileException in classUtils.javassist.reflect |
---|
Methods in classUtils.javassist.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(CompileTimeClass clazz,
CompileTimeClass metaobject,
CompileTimeClass 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.onWrite(ClassPool pool,
java.lang.String classname)
Inserts hooks for intercepting accesses to the fields declared in reflective classes. |
Uses of CannotCompileException in classUtils.javassist.rmi |
---|
Methods in classUtils.javassist.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 classUtils.javassist.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 classUtils.javassist.sample.evolve |
---|
Methods in classUtils.javassist.sample.evolve that throw CannotCompileException | |
---|---|
void |
Evolution.makeUpdatable(java.lang.String classname)
|
void |
Evolution.onWrite(ClassPool _pool,
java.lang.String classname)
|
Uses of CannotCompileException in classUtils.javassist.sample.rmi |
---|
Methods in classUtils.javassist.sample.rmi that throw CannotCompileException | |
---|---|
static void |
Counter.main(java.lang.String[] args)
|
Uses of CannotCompileException in classUtils.javassist.sample.vector |
---|
Methods in classUtils.javassist.sample.vector that throw CannotCompileException | |
---|---|
CompileTimeClass[] |
VectorAssistant.assist(ClassPool pool,
java.lang.String vec,
java.lang.String[] args)
Calls makeSubclass() and produces a new vector class. |
CompileTimeClass |
VectorAssistant.makeSubclass(ClassPool pool,
CompileTimeClass type)
Produces a new vector class. |
CompileTimeClass |
VectorAssistant.makeSubclass2(ClassPool pool,
CompileTimeClass type)
Produces a new vector class. |
Uses of CannotCompileException in classUtils.putils |
---|
Methods in classUtils.putils that throw CannotCompileException | |
---|---|
static java.lang.Class |
ClassPathUtils.getClass(java.io.File f1)
This will allow the user to adjust the class path until a class loads. |
static java.lang.Class |
ClassPathUtils.getClassFromFile()
|
static void |
ClassPathUtils.testGetClass()
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |