Uses of Class
javassist.CannotCompileException

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.preproc A sample preprocessor. 
javassist.reflect Runtime Reflection. 
javassist.rmi Remote Method Invocation. 
 

Uses of CannotCompileException in javassist
 

Methods in javassist that throw CannotCompileException
 void Translator.start(ClassPool pool)
          Is invoked by a ClassPool for initialization when the object is attached to a ClassPool object.
 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.
static void SerialVersionUID.setSerialVersionUID(CtClass clazz)
          Adds serialVersionUID if one does not already exist.
static CtMethod CtNewMethod.make(java.lang.String src, CtClass declaring)
          Compiles the given source code and creates a method.
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.
static CtMethod CtNewMethod.make(CtClass returnType, java.lang.String mname, CtClass[] parameters, CtClass[] exceptions, java.lang.String body, CtClass declaring)
          Creates a public method.
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 CtMethod CtNewMethod.getter(java.lang.String methodName, CtField field)
          Creates a public getter method.
static CtMethod CtNewMethod.setter(java.lang.String methodName, CtField field)
          Creates a public setter method.
static CtMethod CtNewMethod.delegator(CtMethod delegate, CtClass declaring)
          Creates a method forwarding to a delegate in a super 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 CtConstructor CtNewConstructor.make(java.lang.String src, CtClass declaring)
          Compiles the given source code and creates a constructor.
static CtConstructor CtNewConstructor.make(CtClass[] parameters, CtClass[] exceptions, java.lang.String body, CtClass declaring)
          Creates a public constructor.
static CtConstructor CtNewConstructor.copy(CtConstructor c, CtClass declaring, ClassMap map)
          Creats a copy of a constructor.
static CtConstructor CtNewConstructor.defaultConstructor(CtClass declaring)
          Creates a default (public) constructor.
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.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.
 void CtMethod.setBody(java.lang.String src)
          Sets a method body.
 void CtMethod.setBody(CtMethod src, ClassMap map)
          Copies a method body from another method.
 void CtMethod.setWrappedBody(CtMethod mbody, CtMethod.ConstParameter constParam)
          Replace a method body with a new method body wrapping the given method.
 void CtMethod.useCflow(java.lang.String name)
          Declares to use $cflow for this method.
 void CtMethod.instrument(CodeConverter converter)
          Modifies the method body.
 void CtMethod.instrument(ExprEditor editor)
          Modifies the method body.
 void CtMethod.insertBefore(java.lang.String src)
          Inserts bytecode at the beginning of the method body.
 void CtMethod.insertAfter(java.lang.String src)
          Inserts bytecode at the end of the method body.
 void CtMethod.insertAfter(java.lang.String src, boolean asFinally)
          Inserts bytecode at the end of the method body.
 void CtMethod.addCatch(java.lang.String src, CtClass exceptionType)
          Adds a catch clause that handles an exception thrown in the method body.
static CtField CtField.make(java.lang.String src, CtClass declaring)
          Compiles the given source code and creates a field.
 void CtConstructor.setBody(java.lang.String src)
          Sets a constructor body.
 void CtConstructor.setBody(CtConstructor src, ClassMap map)
          Copies a constructor body from another constructor.
 void CtConstructor.useCflow(java.lang.String name)
          Declares to use $cflow for this constructor.
 void CtConstructor.instrument(CodeConverter converter)
          Modifies the constructor body.
 void CtConstructor.instrument(ExprEditor editor)
          Modifies the constructor body.
 void CtConstructor.insertBefore(java.lang.String src)
          Inserts bytecode at the beginning of the constructor body.
 void CtConstructor.insertBeforeBody(java.lang.String src)
          Inserts bytecode just after another constructor in the super class or this class is called.
 void CtConstructor.insertAfter(java.lang.String src)
          Inserts bytecode at the end of the constructor body.
 void CtConstructor.insertAfter(java.lang.String src, boolean asFinally)
          Inserts bytecode at the end of the constructor body.
 void CtConstructor.addCatch(java.lang.String src, CtClass exceptionType)
          Adds a catch clause that handles an exception thrown in the constructor body.
 void CtClass.setSuperclass(CtClass clazz)
          Changes a super class.
 CtConstructor CtClass.makeClassInitializer()
          Makes a class initializer (static constructor).
 void CtClass.addConstructor(CtConstructor c)
          Adds a constructor.
 void CtClass.addMethod(CtMethod m)
          Adds a method.
 void CtClass.addField(CtField f)
          Adds a field.
 void CtClass.addField(CtField f, java.lang.String init)
          Adds a field with an initial value.
 void CtClass.addField(CtField f, CtField.Initializer init)
          Adds a field with an initial value.
 void CtClass.instrument(CodeConverter converter)
          Applies the given converter to all methods and constructors declared in the class.
 void CtClass.instrument(ExprEditor editor)
          Modifies the bodies of all methods and constructors declared in the class.
 java.lang.Class CtClass.toClass()
          Converts this class to a java.lang.Class object.
 byte[] CtClass.toBytecode()
          Converts this class to a class file.
 void CtClass.writeFile()
          Writes a class file represented by this CtClass object in the current directory.
 void CtBehavior.setBody(java.lang.String src)
          Sets a member body.
 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 at runtime (other Javassist classes are not required at runtime).
 void CtBehavior.instrument(CodeConverter converter)
          Modifies the member body.
 void CtBehavior.instrument(ExprEditor editor)
          Modifies the member body.
 void CtBehavior.insertBefore(java.lang.String src)
          Inserts bytecode at the beginning of the body.
 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 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 CodeConverter.redirectMethodCall(CtMethod origMethod, CtMethod substMethod)
          Modify method invocations in a method body so that a different method is invoked.
 void CodeConverter.insertBeforeMethod(CtMethod origMethod, CtMethod beforeMethod)
          Insert a call to another method before an existing method call.
 void CodeConverter.insertAfterMethod(CtMethod origMethod, CtMethod afterMethod)
          Inserts a call to another method after an existing method call.
 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.
 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.
 java.lang.Class ClassPool.writeAsClass(java.lang.String classname)
          Returns a java.lang.Class object.
 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.
 

Constructors in javassist that throw CannotCompileException
CtMethod(CtMethod src, CtClass declaring, ClassMap map)
          Creates a copy of a CtMethod 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.
CtConstructor(CtConstructor src, CtClass declaring, ClassMap map)
          Creates a copy of a CtConstructor object.
 

Uses of CannotCompileException in javassist.bytecode
 

Methods in javassist.bytecode that throw CannotCompileException
 void ClassFile.setSuperclass(java.lang.String superclass)
          Sets the super class.
 

Uses of CannotCompileException in javassist.expr
 

Methods in javassist.expr that throw CannotCompileException
 void NewExpr.replace(java.lang.String statement)
          Replaces the new 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 Instanceof.replace(java.lang.String statement)
          Replaces the instanceof operator with the bytecode derived from the given source text.
 void Handler.replace(java.lang.String statement)
          This method has not been implemented yet.
 void Handler.insertBefore(java.lang.String src)
          Inserts bytecode at the beginning of the catch clause.
 void FieldAccess.replace(java.lang.String statement)
          Replaces the method call with the bytecode derived from the given source text.
 boolean ExprEditor.doit(CtClass clazz, MethodInfo minfo)
          Undocumented method.
 void ExprEditor.edit(NewExpr e)
          Edits a new expression (overridable).
 void ExprEditor.edit(MethodCall m)
          Edits a method call (overridable).
 void ExprEditor.edit(FieldAccess f)
          Edits a field-access expression (overridable).
 void ExprEditor.edit(Instanceof i)
          Edits an instanceof expression (overridable).
 void ExprEditor.edit(Cast c)
          Edits an expression for explicit type casting (overridable).
 void ExprEditor.edit(Handler h)
          Edits a catch clause (overridable).
 void Cast.replace(java.lang.String statement)
          Replaces the explicit cast operator with the bytecode derived from the given source text.
 

Uses of CannotCompileException in javassist.preproc
 

Methods in javassist.preproc that throw CannotCompileException
 void Compiler.process()
          Starts preprocessing.
 CtClass[] 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.
 

Constructors in javassist.preproc that throw CannotCompileException
Compiler(java.lang.String inputname)
          Constructs a Compiler with a source file.
 

Uses of CannotCompileException in javassist.reflect
 

Methods in javassist.reflect that throw CannotCompileException
 void Reflection.onWrite(ClassPool pool, java.lang.String classname)
          Inserts hooks for intercepting accesses to the fields declared in reflective classes.
 boolean Reflection.makeReflective(java.lang.String classname, java.lang.String metaobject, java.lang.String metaclass)
          Produces a reflective class.
 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 Loader.makeReflective(java.lang.String clazz, java.lang.String metaobject, java.lang.String metaclass)
          Produces a reflective class.
 

Uses of CannotCompileException in javassist.rmi
 

Methods in javassist.rmi that throw CannotCompileException
 boolean StubGenerator.makeProxyClass(java.lang.Class clazz)
          Makes a proxy class.
 int AppletServer.exportObject(java.lang.String name, java.lang.Object obj)
          Exports an object.
 

Constructors in javassist.rmi that throw CannotCompileException
AppletServer(java.lang.String port)
          Constructs a web server.
AppletServer(int port)
          Constructs a web server.
AppletServer(int port, ClassPool src)
          Constructs a web server.
 



Javassist, a Java-bytecode translator toolkit. Copyright (C) 1999-2003 Shigeru Chiba. All Rights Reserved.