javassist
public class CtNewMethod extends Object
CtMethod
.
An instance of this class does not make any sense.
See Also: addMethod
Method Summary | |
---|---|
static CtMethod | abstractMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, CtClass declaring)
Creates a public abstract method.
|
static CtMethod | copy(CtMethod src, CtClass declaring, ClassMap map)
Creates a copy of a method. |
static CtMethod | copy(CtMethod src, String name, CtClass declaring, ClassMap map)
Creates a copy of a method with a new name.
|
static CtMethod | delegator(CtMethod delegate, CtClass declaring)
Creates a method forwarding to a delegate in
a super class. |
static CtMethod | getter(String methodName, CtField field)
Creates a public getter method. |
static CtMethod | make(String src, CtClass declaring)
Compiles the given source code and creates a method.
|
static CtMethod | make(String src, CtClass declaring, String delegateObj, String delegateMethod)
Compiles the given source code and creates a method.
|
static CtMethod | make(CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)
Creates a public (non-static) method. |
static CtMethod | make(int modifiers, CtClass returnType, String mname, CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)
Creates a method.
|
static CtMethod | setter(String methodName, CtField field)
Creates a public setter method. |
static CtMethod | wrapped(CtClass returnType, String mname, CtClass[] parameterTypes, CtClass[] exceptionTypes, CtMethod body, CtMethod.ConstParameter constParam, CtClass declaring)
Creates a wrapped method. |
Parameters: returnType the type of the returned value mname the method name parameters a list of the parameter types exceptions a list of the exception types declaring the class to which the created method is added.
See Also: (CtClass,String,CtClass[],CtClass)
Parameters: src the source method. declaring the class to which the created method is added. map the hashtable associating original class names
with substituted names.
It can be null
.
See Also: CtMethod
Parameters: src the source method. name the name of the created method. declaring the class to which the created method is added. map the hashtable associating original class names
with substituted names.
It can be null
.
See Also: CtMethod
delegate
with all the parameters passed to the
created method. If the delegate method returns a value,
the created method returns that value to the caller.
The delegate method must be declared in a super class.
The following method is an example of the created method.
int f(int p, int q) { return super.f(p, q); }
The name of the created method can be changed by
setName()
.
Parameters: delegate the method that the created method forwards to. declaring the class to which the created method is added.
Parameters: methodName the name of the getter field the field accessed.
"public Object id(Object obj) { return obj; }"
Parameters: src the source text. declaring the class to which the created method is added.
"public Object id(Object obj) { return obj; }"
If the source code includes $proceed()
, then
it is compiled into a method call on the specified object.
Parameters: src the source text. declaring the class to which the created method is added. delegateObj the source text specifying the object
that is called on by $proceed()
. delegateMethod the name of the method
that is called by $proceed()
.
Parameters: returnType the type of the returned value. mname the method name. parameters a list of the parameter types. exceptions a list of the exception types. body the source text of the method body.
It must be a block surrounded by {}
.
If it is null
, the created method
does nothing except returning zero or null. declaring the class to which the created method is added.
Parameters: modifiers access modifiers. returnType the type of the returned value. mname the method name. parameters a list of the parameter types. exceptions a list of the exception types. body the source text of the method body.
It must be a block surrounded by {}
.
If it is null
, the created method
does nothing except returning zero or null. declaring the class to which the created method is added.
See Also: Modifier
setModifiers()
in CtBehavior
.
Parameters: methodName the name of the setter field the field accessed.
Object
.
The body of the created method is a copy of the body of a method
specified by body
. However, it is wrapped in
parameter-conversion code.
The method specified by body
must have this singature:
Object method(Object[] params, <type> cvalue)
The type of the cvalue
depends on
constParam
.
If constParam
is null
, the signature
must be:
Object method(Object[] params)
The method body copied from body
is wrapped in
parameter-conversion code, which converts parameters specified by
parameterTypes
into an array of Object
.
The returned value is also converted from the Object
type to the type specified by returnType
. Thus,
the resulting method body is as follows:
Object[] params = new Object[] { p0, p1, ... }; <type> cvalue = <constant-value>; ... copied method body ... Object result = <returned value> return (<returnType>)result;
The variables p0
, p2
, ... represent
formal parameters of the created method.
The value of cvalue
is specified by
constParam
.
If the type of a parameter or a returned value is a primitive
type, then the value is converted into a wrapper object such as
java.lang.Integer
. If the type of the returned value
is void
, the returned value is discarded.
Example:
ClassPool pool = ... ; CtClass vec = pool.makeClass("intVector"); vec.setSuperclass(pool.get("java.util.Vector")); CtMethod addMethod = pool.getMethod("Sample", "add0"); CtClass[] argTypes = { CtClass.intType }; CtMethod m = CtNewMethod.wrapped(CtClass.voidType, "add", argTypes, null, addMethod, null, vec); vec.addMethod(m);
where the class Sample
is as follows:
public class Sample extends java.util.Vector { public Object add0(Object[] args) { super.addElement(args[0]); return null; } }
This program produces a class intVector
:
public class intVector extends java.util.Vector { public void add(int p0) { Object[] args = new Object[] { p0 }; // begin of copied body super.addElement(args[0]); Object result = null; // end } }
Note that the type of the parameter to add()
depends
only on the value of argTypes
passed to
CtNewMethod.wrapped()
. Thus, it is easy to
modify this program to produce a
StringVector
class, which is a vector containing
only String
objects, and other vector classes.
Parameters: returnType the type of the returned value. mname the method name. parameterTypes a list of the parameter types. exceptionTypes a list of the exception types. body the method body
(must not be a static method). constParam the constant parameter
(maybe null
). declaring the class to which the created method is
added.