public Class CtNewMethod

Creates a public abstract method.

Parameters

returnType:CtClass

the type of the returned value

mname:String

the method name

parameters:CtClass[]

a list of the parameter types

exceptions:CtClass[]

a list of the exception types

declaring:CtClass

the class to which the created method is added.

See Also

CtMethod#CtMethod(CtClass, String, CtClass[], CtClass)

Creates a copy of a method. This method is provided for creating a new method based on an existing method. This is a convenience method for calling this constructor. See the description of the constructor for particular behavior of the copying.

Parameters

src:CtMethod

the source method.

declaring:CtClass

the class to which the created method is added.

map:ClassMap

the hash table associating original class names with substituted names. It can be null.

See Also

CtMethod#CtMethod(CtMethod, CtClass, ClassMap)

Creates a copy of a method with a new name. This method is provided for creating a new method based on an existing method. This is a convenience method for calling this constructor. See the description of the constructor for particular behavior of the copying.

Parameters

src:CtMethod

the source method.

name:String

the name of the created method.

declaring:CtClass

the class to which the created method is added.

map:ClassMap

the hash table associating original class names with substituted names. It can be null.

See Also

CtMethod#CtMethod(CtMethod, CtClass, ClassMap)

Creates a method forwarding to a delegate in a super class. The created method calls a method specified by 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:CtMethod

the method that the created method forwards to.

declaring:CtClass

the class to which the created method is added.

Creates a public getter method. The getter method returns the value of the specified field in the class to which this method is added. The created method is initially not static even if the field is static. Change the modifiers if the method should be static.

Parameters

methodName:String

the name of the getter

field:CtField

the field accessed.

Compiles the given source code and creates a method. The source code must include not only the method body but the whole declaration, for example,

"public Object id(Object obj) { return obj; }"

Parameters

src:String

the source text.

declaring:CtClass

the class to which the created method is added.

Compiles the given source code and creates a method. The source code must include not only the method body but the whole declaration, for example,

"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:String

the source text.

declaring:CtClass

the class to which the created method is added.

delegateObj:String

the source text specifying the object that is called on by $proceed().

delegateMethod:String

the name of the method that is called by $proceed().

Creates a public (non-static) method. The created method cannot be changed to a static method later.

Parameters

returnType:CtClass

the type of the returned value.

mname:String

the method name.

parameters:CtClass[]

a list of the parameter types.

exceptions:CtClass[]

a list of the exception types.

body:String

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:CtClass

the class to which the created method is added.

See Also

make(int, CtClass, String, CtClass[], CtClass[], String, CtClass)

Creates a method. modifiers can contain Modifier.STATIC.

Parameters

modifiers:int

access modifiers.

returnType:CtClass

the type of the returned value.

mname:String

the method name.

parameters:CtClass[]

a list of the parameter types.

exceptions:CtClass[]

a list of the exception types.

body:String

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:CtClass

the class to which the created method is added.

See Also

Modifier

Creates a public setter method. The setter method assigns the value of the first parameter to the specified field in the class to which this method is added. The created method is not static even if the field is static. You may not change it to be static by setModifiers() in CtBehavior.

Parameters

methodName:String

the name of the setter

field:CtField

the field accessed.

Creates a wrapped method. The wrapped method receives parameters in the form of an array of Object.

The body of the created method is a copy of the body of the 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 the 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:CtClass

the type of the returned value.

mname:String

the method name.

parameterTypes:CtClass[]

a list of the parameter types.

exceptionTypes:CtClass[]

a list of the exception types.

body:CtMethod

the method body (must not be a static method).

constParam:CtMethod.ConstParameter

the constant parameter (maybe null).

declaring:CtClass

the class to which the created method is added.