4. Introspection and customization
Methods are represented by
For example, if class Javassist does not allow to add an extra parameter to an existing
method, either. Instead of doing that, a new method receiving the
extra parameter as well as the other parameters should be added to the
same class. For example, if you want to add an extra in a Javassist also provides low-level API for directly editing a raw
class file. For example, The class files modified by Javassist requires the
Inserting a code fragment at the position specified by a line number
is also possible
(if the line number table is contained in the class file).
The methods The statement and the block can refer to fields and methods.
They can also refer to the parameters
to the method that they are inserted into
if that method was compiled with the -g option
(to include a local variable attribute in the class file).
Otherwise, they must access the method parameters through the special
variables The The parameters passed to the target method
are accessible with
These variables are used as following. Suppose that a class
To print the values of Note that the source text passed to The definition of the class The variable If an array of The variable is equivalent to this:
If then this expression is equivalent to:
Note that Suppose that the method shown below is represented by a
To use The parameter to Then, translates the method The value of If the result type is a primitive type, then If the result type is is a valid statement.
The cast operator Here, The selected wrapper type depends on the type of the expression
following If the type of the expression following The variable Although the compiled code inserted by If an exception is thrown, the compiled code inserted by
The value of The value of The value of For example, this program:
translates the method body represented by Note that the inserted code fragment must end with a
In the source text given to Javassist allows modifying only an expression included in a method body.
To run an searches the method body represented by so that the first parameter to The method Calling whichever the expression is either a method call, field access,
object creation, or others. The second statement could be:
if the expression is read access, or
if the expression is write access.
Local variables available in the target expression is
also available in the source text passed to A Here the method call means the one represented by the
The other identifiers such as Unless the result type of the method call is A Here the constructor call means the one represented by the
The other identifiers such as Since any constructor must call either a constructor of the super
class or another constructor of the same class,
the substituted statement must include a constructor call,
normally a call to A
In the source text, the identifiers starting with The other identifiers such as If the expression is read access, a value must be assigned to
A
In the source text, the identifiers starting with The other identifiers such as A
In the source text, the identifiers starting with The other identifiers such as For example, if the array creation is the following expression,
If the array creation is the following expression,
A
In the source text, the identifiers starting with The other identifiers such as A
In the source text, the identifiers starting with The other identifiers such as A
In the source text, the identifiers starting with If a new exception object is assigned to Javassist allows the users to create a new method and constructor
from scratch. For example, this program:
adds a public method The source text passed to this program creates a method Note that Javassist provides another way to add a new method.
You can first create an abstract method and later give it a method body:
Since Javassist makes a class abstract if an abstract method is
added to the class, you have to explicitly change the class back to a
non-abstract one after calling Javassist cannot compile a method if it calls another method that
has not been added to a class. (Javassist can compile a method that
calls itself recursively.) To add mutual recursive methods to a class,
you need a trick shown below. Suppose that you want to add methods
You must first make two abstract methods and add them to the class.
Then you can give the method bodies to these methods even if the method
bodies include method calls to each other. Finally you must change the
class to a not-abstract class since Javassist also allows the users to create a new field.
This program adds a field named If the initial value of the added field must be specified,
the program shown above must be modified into:
Now, the method Furthermore, the above code can be rewritten into the following
simple code:
To remove a field or a method, call For example, suppose the following annotation:
This annotation is used as the following:
Then, the value of the annotation can be obtained by
This code snippet should print:
Since the annoation of To use In most cases, a class modified by Javassist does not require
Javassist to run. However, some kinds of bytecode generated by the
Javassist compiler need runtime support classes, which are in the
All the class names in source code must be fully qualified
(they must include package names).
However, the To tell the compiler to search other packages when resolving a
class name, call The seconde line instructs the compiler
to import the Note that In the current implementation, the Java compiler included in Javassist
has several limitations with respect to the language that the compiler can
accept. Those limitations are:
For example,
If the compiled expression is calls a method so that the compiler can quickly parse the expression.
4. Introspection and customization
CtClass
provides methods for introspection. The
introspective ability of Javassist is compatible with that of
the Java reflection API. CtClass
provides
getName()
, getSuperclass()
,
getMethods()
, and so on.
CtClass
also provides methods for modifying a class
definition. It allows to add a new field, constructor, and method.
Instrumenting a method body is also possible.
CtMethod
objects.
CtMethod
provides several methods for modifying
the definition of the method. Note that if a method is inherited
from a super class, then
the same CtMethod
object
that represents the inherited method represents the method declared
in that super class.
A CtMethod
object corresponds to every method declaration.
Point
declares method move()
and a subclass ColorPoint
of Point
does
not override move()
, the two move()
methods
declared in Point
and inherited in ColorPoint
are represented by the identical CtMethod
object.
If the method definition represented by this
CtMethod
object is modified, the modification is
reflected on both the methods.
If you want to modify only the move()
method in
ColorPoint
, you first have to add to ColorPoint
a copy of the CtMethod
object representing move()
in Point
. A copy of the the CtMethod
object
can be obtained by CtNewMethod.copy()
.
Javassist does not allow to remove a method or field, but it allows
to change the name. So if a method is not necessary any more, it should be
renamed and changed to be a private method by calling
setName()
and setModifiers()
declared in CtMethod
.
int
parameter newZ
to a method:
void move(int newX, int newY) { x = newX; y = newY; }
Point
class, then you should add the following
method to the Point
class:
void move(int newX, int newY, int newZ) {
// do what you want with newZ.
move(newX, newY);
}
getClassFile()
in
CtClass
returns a ClassFile
object
representing a raw class file. getMethodInfo()
in
CtMethod
returns a MethodInfo
object
representing a method_info
structure included in a class
file. The low-level API uses the vocabulary from the Java Virtual
machine specification. The users must have the knowledge about class
files and bytecode. For more details, the users should see the
javassist.bytecode
package.
javassist.runtime
package for runtime support
only if some special identifiers starting with $
are used. Those special identifiers are described below.
The class files modified without those special identifiers
do not need the javassist.runtime
package or any
other Javassist packages at runtime.
For more details, see the API documentation
of the javassist.runtime
package.
4.1 Inserting source text at the beginning/end of a method body
CtMethod
and CtConstructor
provide
methods insertBefore()
, insertAfter()
, and
addCatch()
. They are used for inserting a code fragment
into the body of an existing method. The users can specify those code
fragments with source text written in Java.
Javassist includes a simple Java compiler for processing source
text. It receives source text
written in Java and compiles it into Java bytecode, which will be
inlined into a method body.
insertAt()
in CtMethod
and
CtConstructor
takes source text and a line number in the source
file of the original class definition.
It compiles the source text and inserts the compiled code at the line number.
insertBefore()
, insertAfter()
,
addCatch()
, and insertAt()
receive a String
object representing
a statement or a block. A statement is a single control structure like
if
and while
or an expression ending with
a semi colon (;
). A block is a set of
statements surrounded with braces {}
.
Hence each of the following lines is an example of valid statement or block:
System.out.println("Hello");
{ System.out.println("Hello"); }
if (i < 0) { i = -i; }
$0
, $1
, $2
, ... described
below.
Accessing local variables declared in the method is not allowed
although declaring a new local variable in the block is allowed.
However, insertAt()
allows the statement and the block
to access local variables
if these variables are available at the specified line number
and the target method was compiled with the -g option.
String
object passed to the methods
insertBefore()
, insertAfter()
,
addCatch()
, and insertAt()
are compiled by
the compiler included in Javassist.
Since the compiler supports language extensions,
several identifiers starting with $
have special meaning:
$0
, $1
, $2
, ...    this
and actual parameters
$args
An array of parameters.
The type of
$args
is Object[]
.
$$
All actual parameters.
For example, m($$)
is equivalent to
m($1,$2,
...)

$cflow(
...)
cflow
variable
$r
The result type. It is used in a cast expression.
$w
The wrapper type. It is used in a cast expression.
$_
The resulting value
$sig
An array of
java.lang.Class
objects representing
the formal parameter types.
$type
A
java.lang.Class
object representing
the formal result type.
$class
A
java.lang.Class
object representing
the class currently edited.$0, $1, $2, ...
$1
, $2
, ... instead of
the original parameter names.
$1
represents the
first parameter, $2
represents the second parameter, and
so on. The types of those variables are identical to the parameter
types.
$0
is
equivalent to this
. If the method is static,
$0
is not available.
Point
:
class Point {
int x, y;
void move(int dx, int dy) { x += dx; y += dy; }
}
dx
and dy
whenever the method move()
is called, execute this
program:
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
CtMethod m = cc.getDeclaredMethod("move");
m.insertBefore("{ System.out.println($1); System.out.println($2); }");
cc.writeFile();
insertBefore()
is
surrounded with braces {}
.
insertBefore()
accepts only a single statement or a block
surrounded with braces.
Point
after the
modification is like this:
class Point {
int x, y;
void move(int dx, int dy) {
{ System.out.println(dx); System.out.println(dy); }
x += dx; y += dy;
}
}
$1
and $2
are replaced with
dx
and dy
, respectively.
$1
, $2
, $3
... are
updatable. If a new value is assigend to one of those variables,
then the value of the parameter represented by that variable is
also updated.
$args
$args
represents an array of all the
parameters. The type of that variable is an array of class
Object
. If a parameter type is a primitive type such as
int
, then the parameter value is converted into a wrapper
object such as java.lang.Integer
to store in
$args
. Thus, $args[0]
is equivalent to
$1
unless the type of the first parameter is a primitive
type. Note that $args[0]
is not equivalent to
$0
; $0
represents this
.
Object
is assigned to
$args
, then each element of that array is
assigned to each parameter. If a parameter type is a primitive
type, the type of the corresponding element must be a wrapper type.
The value is converted from the wrapper type to the primitive type
before it is assigned to the parameter.
$$
$$
is abbreviation of a list of
all the parameters separated by commas.
For example, if the number of the parameters
to method move()
is three, then
move($$)
move($1, $2, $3)
move()
does not take any parameters,
then move($$)
is
equivalent to move()
.
$$
can be used with another method.
If you write an expression:
exMove($$, context)
exMove($1, $2, $3, context)
$$
enables generic notation of method call
with respect to the number of parameters.
It is typically used with $proceed
shown later.
$cflow
$cflow
means "control flow".
This read-only variable returns the depth of the recursive calls
to a specific method.
CtMethod
object cm
:
int fact(int n) {
if (n <= 1)
return n;
else
return n * fact(n - 1);
}
$cflow
, first declare that $cflow
is used for monitoring calls to the method fact()
:
CtMethod cm = ...;
cm.useCflow("fact");
useCflow()
is the identifier of the
declared $cflow
variable. Any valid Java name can be
used as the identifier. Since the identifier can also include
.
(dot), for example, "my.Test.fact"
is a valid identifier.
$cflow(fact)
represents the depth of the
recursive calls to the method specified by cm
. The value
of $cflow(fact)
is 0 (zero) when the method is
first called whereas it is 1 when the method is recursively called
within the method. For example,
cm.insertBefore("if ($cflow(fact) == 0)"
+ " System.out.println(\"fact \" + $1);");
fact()
so that it shows the
parameter. Since the value of $cflow(fact)
is checked,
the method fact()
does not show the parameter if it is
recursively called within fact()
.
$cflow
is the number of stack frames
associated with the specified method cm
under the current topmost
stack frame for the current thread. $cflow
is also
accessible within a method different from the specified method
cm
.
$r
$r
represents the result type (return type) of the method.
It must be used as the cast type in a cast expression.
For example, this is a typical use:
Object result = ... ;
$_ = ($r)result;
($r)
follows special semantics. First, if the operand type of the cast
expression is a primitive type, ($r)
works as a normal
cast operator to the result type.
On the other hand, if the operand type is a wrapper type,
($r)
converts from the wrapper type to the result type.
For example, if the result type is int
, then
($r)
converts from java.lang.Integer
to
int
.
void
, then
($r)
does not convert a type; it does nothing.
However, if the operand is a call to a void
method,
then ($r)
results in null
. For example,
if the result type is void
and
foo()
is a void
method, then
$_ = ($r)foo();
($r)
is also useful in a
return
statement. Even if the result type is
void
, the following return
statement is valid:
return ($r)result;
result
is some local variable.
Since ($r)
is specified, the resulting value is
discarded.
This return
statement is regarded as the equivalent
of the return
statement without a resulting value:
return;
$w
$w
represents a wrapper type.
It must be used as the cast type in a cast expression.
($w)
converts from a primitive type to the corresponding
wrapper type.
The following code is an example:
Integer i = ($w)5;
($w)
. If the type of the expression is
double
, then the wrapper type is java.lang.Double
.
($w)
is not
a primitive type, then ($w)
does nothing.
$_
insertAfter()
in CtMethod
and
CtConstructor
inserts the
compiled code at the end of the method. In the statement given to
insertAfter()
, not only the variables shown above such as
$0
, $1
, ... but also $_
is
available.
$_
represents the resulting value of the
method. The type of that variable is the type of the result type (the
return type) of the method. If the result type is void
,
then the type of $_
is Object
and the value
of $_
is null
.
insertAfter()
is executed just before the control normally returns from the method,
it can be also executed when an exception is thrown from the method.
To execute it when an exception is thrown, the second parameter
asFinally
to insertAfter()
must be
true
.
insertAfter()
is executed as a finally
clause. The value of $_
is 0
or
null
in the compiled code. After the execution of the
compiled code terminates, the exception originally thrown is re-thrown
to the caller. Note that the value of $_
is never thrown
to the caller; it is rather discarded.
$sig
$sig
is an array of
java.lang.Class
objects that represent the formal
parameter types in declaration order.
$type
$type
is an java.lang.Class
object representing the formal type of the result value. This
variable refers to Void.class
if this is a constructor.
$class
$class
is an java.lang.Class
object representing the class in which the edited method is declared.
This represents the type of $0
.
addCatch()
addCatch()
inserts a code fragment into a method body
so that the code fragment is executed when the method body throws
an exception and the control returns to the caller. In the source
text representing the inserted code fragment, the exception value
is referred to with the special variable $e
.
CtMethod m = ...;
CtClass etype = ClassPool.getDefault().get("java.io.IOException");
m.addCatch("{ System.out.println($e); throw $e; }", etype);
m
into
something like this:
try {
the original method body
}
catch (java.io.IOException e) {
System.out.println(e);
throw e;
}
throw
or return
statement.
4.2 Altering a method body
CtMethod
and CtConstructor
provide
setBody()
for substituting a whole
method body. They compile the given source text into Java bytecode
and substitutes it for the original method body. If the given source
text is null
, the substituted body includes only a
return
statement, which returns zero or null unless the
result type is void
.
setBody()
, the identifiers
starting with $
have special meaning
Note that
$0
, $1
, $2
, ...    this
and actual parameters
$args
An array of parameters.
The type of
$args
is Object[]
.
$$
All actual parameters.
$cflow(
...)
cflow
variable
$r
The result type. It is used in a cast expression.
$w
The wrapper type. It is used in a cast expression.
$sig
An array of
java.lang.Class
objects representing
the formal parameter types.
$type
A
java.lang.Class
object representing
the formal result type.
$class
A
java.lang.Class
object representing
the class that declares the method
currently edited (the type of $0).  $_
is not available.
Substituting source text for an existing expression
javassist.expr.ExprEditor
is a class
for replacing an expression in a method body.
The users can define a subclass of ExprEditor
to specify how an expression is modified.
ExprEditor
object, the users must
call instrument()
in CtMethod
or
CtClass
.
For example,
CtMethod cm = ... ;
cm.instrument(
new ExprEditor() {
public void edit(MethodCall m)
throws CannotCompileException
{
if (m.getClassName().equals("Point")
&& m.getMethodName().equals("move"))
m.replace("{ $1 = 0; $_ = $proceed($$); }");
}
});
cm
and
replaces all calls to move()
in class Point
with a block:
{ $1 = 0; $_ = $proceed($$); }
move()
is always 0.
Note that the substituted code is not an expression but
a statement or a block. It cannot be or contain a try-catch statement.
instrument()
searches a method body.
If it finds an expression such as a method call, field access, and object
creation, then it calls edit()
on the given
ExprEditor
object. The parameter to edit()
is an object representing the found expression. The edit()
method can inspect and replace the expression through that object.
replace()
on the parameter to edit()
substitutes the given statement or block for the expression. If the given
block is an empty block, that is, if replace("{}")
is executed, then the expression is removed from the method body.
If you want to insert a statement (or a block) before/after the
expression, a block like the following should be passed to
replace()
:
{ before-statements;
$_ = $proceed($$);
after-statements; }
$_ = $proceed();
$proceed($$);
replace()
if the method searched by instrument()
was compiled
with the -g option (the class file includes a local variable
attribute).
javassist.expr.MethodCall
MethodCall
object represents a method call.
The method replace()
in
MethodCall
substitutes a statement or
a block for the method call.
It receives source text representing the substitued statement or
block, in which the identifiers starting with $
have special meaning as in the source text passed to
insertBefore()
.
$0
The target object of the method call.
This is not equivalent to this
, which represents
the caller-side this
object.
$0
is null
if the method is static.

$1
, $2
, ...
The parameters of the method call.
$_
The resulting value of the method call.
$r
The result type of the method call.
$class
   A
java.lang.Class
object representing
the class declaring the method.
$sig
   An array of
java.lang.Class
objects representing
the formal parameter types.$type
   A
java.lang.Class
object representing
the formal result type.$proceed
   The name of the method originally called
in the expression.
MethodCall
object.
$w
,
$args
and $$
are also available.
void
,
a value must be assigned to
$_
in the source text and the type of $_
is the result type.
If the result type is void
, the type of $_
is Object
and the value assigned to $_
is ignored.
$proceed
is not a String
value but special
syntax. It must be followed by an argument list surrounded by parentheses
( )
.
javassist.expr.ConstructorCall
ConstructorCall
object represents a constructor call
such as this()
and super
included in a constructor
body.
The method replace()
in
ConstructorCall
substitutes a statement or
a block for the constructor call.
It receives source text representing the substituted statement or
block, in which the identifiers starting with $
have special meaning as in the source text passed to
insertBefore()
.
$0
The target object of the constructor call.
This is equivalent to
this
.
$1
, $2
, ...
The parameters of the constructor call.
$class
   A
java.lang.Class
object representing
the class declaring the constructor.
$sig
   An array of
java.lang.Class
objects representing
the formal parameter types.$proceed
   The name of the constructor originally called
in the expression.
ConstructorCall
object.
$w
,
$args
and $$
are also available.
$proceed()
.
$proceed
is not a String
value but special
syntax. It must be followed by an argument list surrounded by parentheses
( )
.
javassist.expr.FieldAccess
FieldAccess
object represents field access.
The method edit()
in ExprEditor
receives this object if field access is found.
The method replace()
in
FieldAccess
receives
source text representing the substitued statement or
block for the field access.
$
have special meaning:
$0
The object containing the field accessed by the expression.
This is not equivalent to
this
.
this
represents the object that the method including the
expression is invoked on.
$0
is null
if the field is static.

$1
The value that would be stored in the field
if the expression is write access.
Otherwise, $1
is not available.

$_
The resulting value of the field access
if the expression is read access.
Otherwise, the value stored in $_
is discarded.

$r
The type of the field if the expression is read access.
Otherwise, $r
is void
.
  $class
   A java.lang.Class
object representing
the class declaring the field.
$type
A
java.lang.Class
object representing
the field type.$proceed
   The name of a virtual method executing the original
field access.
.
$w
,
$args
and $$
are also available.
$_
in the source text. The type of $_
is the type of the field.
javassist.expr.NewExpr
NewExpr
object represents object creation
with the new
operator (not including array creation).
The method edit()
in ExprEditor
receives this object if object creation is found.
The method replace()
in
NewExpr
receives
source text representing the substitued statement or
block for the object creation.
$
have special meaning:
$0
null
.
$1
, $2
, ...
The parameters to the constructor.
$_
The resulting value of the object creation.
A newly created object must be stored in this variable.

$r
The type of the created object.
$sig
   An array of
java.lang.Class
objects representing
the formal parameter types.$type
   A java.lang.Class
object representing
the class of the created object.
$proceed
   The name of a virtual method executing the original
object creation.
.
$w
,
$args
and $$
are also available.
javassist.expr.NewArray
NewArray
object represents array creation
with the new
operator.
The method edit()
in ExprEditor
receives this object if array creation is found.
The method replace()
in
NewArray
receives
source text representing the substitued statement or
block for the array creation.
$
have special meaning:
$0
null
.
$1
, $2
, ...
The size of each dimension.
$_
The resulting value of the array creation.
A newly created array must be stored in this variable.

$r
The type of the created array.
$type
   A java.lang.Class
object representing
the class of the created array.
$proceed
   The name of a virtual method executing the original
array creation.
.
$w
,
$args
and $$
are also available.
String[][] s = new String[3][4];
then the value of $1 and $2 are 3 and 4, respectively. $3 is not available.
String[][] s = new String[3][];
then the value of $1 is 3 but $2 is not available.
javassist.expr.Instanceof
Instanceof
object represents an instanceof
expression.
The method edit()
in ExprEditor
receives this object if an instanceof expression is found.
The method replace()
in
Instanceof
receives
source text representing the substitued statement or
block for the expression.
$
have special meaning:
$0
null
.
$1
The value on the left hand side of the original
instanceof
operator.
$_
The resulting value of the expression.
The type of
$_
is boolean
.
$r
The type on the right hand side of the
instanceof
operator.
$type
A
java.lang.Class
object representing
the type on the right hand side of the instanceof
operator.
$proceed
   The name of a virtual method executing the original
instanceof
expression.
It takes one parameter (the type is java.lang.Object
)
and returns true
if the parameter value is an instance of the type on the right
hand side of
the original instanceof
operator.
Otherwise, it returns false.
      $w
,
$args
and $$
are also available.
javassist.expr.Cast
Cast
object represents an expression for
explicit type casting.
The method edit()
in ExprEditor
receives this object if explicit type casting is found.
The method replace()
in
Cast
receives
source text representing the substitued statement or
block for the expression.
$
have special meaning:
$0
null
.
$1
The value the type of which is explicitly cast.
$_
The resulting value of the expression.
The type of
$_
is the same as the type
after the explicit casting, that is, the type surrounded
by ( )
.

$r
the type after the explicit casting, or the type surrounded
by
( )
.
$type
A
java.lang.Class
object representing
the same type as $r
.
$proceed
   The name of a virtual method executing the original
type casting.
It takes one parameter of the type java.lang.Object
and returns it after
the explicit type casting specified by the original expression.
    $w
,
$args
and $$
are also available.
javassist.expr.Handler
Handler
object represents a catch
clause of try-catch
statement.
The method edit()
in ExprEditor
receives this object if a catch
is found.
The method insertBefore()
in
Handler
compiles the received
source text and inserts it at the beginning of the catch
clause.
$
have meaning:
$1
The exception object caught by the
catch
clause.
$r
the type of the exception caught by the
catch
clause.
It is used in a cast expression.
$w
The wrapper type. It is used in a cast expression.
$type

A
java.lang.Class
object representing
the type of the exception caught by the catch
clause.
  $1
,
it is passed to the original catch
clause as the caught
exception.
4.3 Adding a new method or field
Adding a method
CtNewMethod
and CtNewConstructor
provide several factory methods,
which are static methods for creating CtMethod
or
CtConstructor
objects.
Especially, make()
creates
a CtMethod
or CtConstructor
object
from the given source text.
CtClass point = ClassPool.getDefault().get("Point");
CtMethod m = CtNewMethod.make(
"public int xmove(int dx) { x += dx; }",
point);
point.addMethod(m);
xmove()
to class Point
.
In this example, x
is a int
field in
the class Point
.
make()
can include the
identifiers starting with $
except $_
as in setBody()
.
It can also include
$proceed
if the target object and the target method name
are also given to make()
. For example,
CtClass point = ClassPool.getDefault().get("Point");
CtMethod m = CtNewMethod.make(
"public int ymove(int dy) { $proceed(0, dy); }",
point, "this", "move");
ymove()
defined below:
public int ymove(int dy) { this.move(0, dy); }
$proceed
has been replaced with
this.move
.
CtClass cc = ... ;
CtMethod m = new CtMethod(CtClass.intType, "move",
new CtClass[] { CtClass.intType }, cc);
cc.addMethod(m);
m.setBody("{ x += $1; }");
cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
setBody()
.
Mutual recursive methods
m()
and n()
to a class represented
by cc
:
CtClass cc = ... ;
CtMethod m = CtNewMethod.make("public abstract int m(int i);", cc);
CtMethod n = CtNewMethod.make("public abstract int n(int i);", cc);
cc.addMethod(m);
cc.addMethod(n);
m.setBody("{ return ($1 <= 0) ? 1 : (n($1 - 1) * $1); }");
n.setBody("{ return m($1); }");
cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
addMethod()
automatically
changes a class into an abstract one if an abstract method is added.
Adding a field
CtClass point = ClassPool.getDefault().get("Point");
CtField f = new CtField(CtClass.intType, "z", point);
point.addField(f);
z
to class
Point
.
CtClass point = ClassPool.getDefault().get("Point");
CtField f = new CtField(CtClass.intType, "z", point);
point.addField(f, "0"); // initial value is 0.
addField()
receives the second parameter,
which is the source text representing an expression computing the initial
value. This source text can be any Java expression if the result type
of the expression matches the type of the field. Note that an expression
does not end with a semi colon (;
).
CtClass point = ClassPool.getDefault().get("Point");
CtField f = CtField.make("public int z = 0;", point);
point.addField(f);
Removing a member
removeField()
or removeMethod()
in CtClass
. A
CtConstructor
can be removed by removeConstructor()
in CtClass
.
4.4 Annotations
CtClass
, CtMethod
, CtField
and CtConstructor
provides a convenient method
getAnnotations()
for reading annotations.
It returns an annotation-type object.
public @interface Author {
String name();
int year();
}
@Author(name="Chiba", year=2005)
public class Point {
int x, y;
}
getAnnotations()
.
It returns an array containing
annotation-type objects.
CtClass cc = ClassPool.getDefault().get("Point");
Object[] all = cc.getAnnotations();
Author a = (Author)all[0];
String name = a.name();
int year = a.year();
System.out.println("name: " + name + ", year: " + year);
name: Chiba, year: 2005
Point
is only @Author
,
the length of the array all
is one
and all[0]
is an Author
object.
The member values of the annotation can be obtained
by calling name()
and year()
on the Author
object.
getAnnotations()
, annotation types
such as Author
must be included in the current
class path. They must be also accessible from a
ClassPool
object. If the class file of an annotation
type is not found, Javassist cannot obtain the default values
of the members of that annotation type.
4.5 Runtime support classes
javassist.runtime
package (for details, please read
the API reference of that package). Note that the
javassist.runtime
package is the only package that
classes modified by Javassist may need for running. The other
Javassist classes are never used at runtime of the modified classes.
4.6 Import
java.lang
package is an
exception; for example, the Javassist compiler can
resolve Object
as
well as java.lang.Object
.
importPackage()
in ClassPool
.
For example,
ClassPool pool = ClassPool.getDefault();
pool.importPackage("java.awt");
CtClass cc = pool.makeClass("Test");
CtField f = CtField.make("public Point p;", cc);
cc.addField(f);
java.awt
package.
Thus, the third line will not throw an exception.
The compiler can recognize Point
as java.awt.Point
.
importPackage()
does not affect
the get()
method in ClassPool
.
Only the compiler considers the imported packages.
The parameter to get()
must be always a fully qualified name.
4.7 Limitations
javassist.bytecode.annotation
package
(and also getAnnotations()
in CtClass
and CtBehavior
).
Generics are also only partly supported. See the latter section for more details.
{
and }
, are not
available unless the array dimension is one.
continue
and break
statements
are not supported.
class A {}
class B extends A {}
class C extends B {}
class X {
void foo(A a) { .. }
void foo(B b) { .. }
}
x.foo(new C())
, where
x
is an instance of X, the compiler may produce a call
to foo(A)
although the compiler can correctly compile
foo((B)new C())
.
#
as the separator
between a class name and a static method or field name.
For example, in regular Java,
javassist.CtClass.intType.getName()
getName()
on
the object indicated by the static field intType
in javassist.CtClass
. In Javassist, the users can
write the expression shown above but they are recommended to
write:
javassist.CtClass#intType.getName()
Java(TM) is a trademark of Sun Microsystems, Inc.
Copyright (C) 2000-2014 by Shigeru Chiba, All rights reserved.


Welcome to our Repo
StarFin is the next big downstreaming and upstreaming service that is based off of Node.JS and the MPEG Dash Protocol. It was made by Beshoy Hanna in Node.JS and will be done by Andrew Kamal, his team mate in PHP. This is their official project for the WSU Hackathon in 2016.
Current Steaming
Current streaming services have trouble supporting MPEG4 protocols, and we wanna create a more integrated alternative for Adobe Flash that best suits Java developers or open source programmers.


For more info visit http://jonraasch.com/blog/a-simple-jquery-slideshow
If you like this script, please make a donation


agentframework module¶
Created on Wed Sep 18 08:26:33 2019
@author: gyral
-
class
agentframework.
Agent
(environment, agents, y=None, x=None)[source]¶ Bases:
object
-
distance_between
(other_agent)[source]¶ # Calculating how far the agents are by using Pythagoras
Agent 1 = self. Agent 2 = other_agent.
- Parameters
other_agent] ([self,) – [pointing to the agent itself
(data type: tuple) and another agent (data type: tuple)] :return: [distance between Agent 1 and Agent 2 by using Pythagoras (data type: float)]
-
eat
()[source]¶ Using the if statement to determine whether agents should eat the environment or not. If the environment is greater than 10 than subtract 10 units from the environment and add it to the agent’s store.
- Parameters
[self] – [pointing to the object itself (data type: tuple)]
- Returns
[values for the “environment” and “store” variables]
-
move
()[source]¶ - Moving agents randomly:
Problem: agents might be missing from the graph if they ended up wandering off the edge.
Solution: Torus - permit agents leaving the top of an area to come in at the bottom and leaving left come in on the right side.
- Parameters
[self] – [pointing to the object itself ((data type: tuple))]
- Returns
[new random x and y values for the parameter self]
Calculating the distance to each of the other agent, and if they tend to be within the neighbourhood distance then sets its and its neighbours stores equal to the average of their two stores
Looping through the agents in self.agents. 1) Calculating the distance between self and the current other agent. 2) If the distance is less than or equal to neighbourhood
(by default 20 is the radius around agents)then add self.store and agent.store.
Calculate the average by dividing the sum by 2.
Store this average into both the self.store and agent.store.
- Parameters
neighbourhood] ([self,) – [pointing to the agent itself
(data type: tuple) and neighbourhood (data type: integer)]
-


By default, what visibility should be given to new items added to your ORCID Record?
Everyone (87% of users choose this) Trusted Organizations (5% of users choose this) Only me (8% of users choose this)
More information on visibility settings


26 March 1999
Disease Outbreak Reported
The following is a Press Release from the World Health Organization, Regional Office for the Western Pacific, WP/PR8, 25 March 1999. For updates on the number of cases and deaths, please visit the web site of the Department of Public Health, Ministry of Health, Malaysia at: http://dph.gov.my/press/press2/japan_e.htm
Cases of viral encephalitis have been occurring in Malaysia since October 1998. To date, there have been 157 cases and 58 deaths. New information indicates that both Japanese encephalitis (JE) and a second virus are circulating. The second virus, a new member of the paramyxovirus family could be similar to the Hendra virus found earlier in Australia. Japanese encephalitis has been confirmed to be the cause of 18 of the reported deaths. Further investigations are now underway to determine the role of the new viruses in the reported cases.
Japanese encephalitis (JE) is the leading cause of viral encephalitis in Asia with 30 000 to 50 000 cases reported annually. Acute encephalitis can lead to paralysis, coma and death. In Malaysia, between 9 and 91 cases of JE are reported each year. Major outbreaks occurred in Langkawi in 1974, Penang in 1988 and in the Serian district of Sarawak in 1992.
Japanese encephalitis virus usually affects pigs and is transmitted by the bite of culex mosquitos. Normally the disease is transmitted among pigs and it is only in exceptional circumstances that humans are involved.
The initial stages of the current outbreak evidence pointed to JE because of the association of all the cases with pigs and piggeries. However, JE usually affects children but most of the cases in this outbreak have been young adult males. All have been workers at or closely associated with piggeries. This suggests the presence of another virus.
The current outbreak of viral encephalitis involves the Kinta district of Perak and the Sikamat and Bukit Pelandok districts of Negri Sembilan state. The highest number of cases and deaths have been reported from Bukit Pelandok.
The Malaysian Ministry of Health has mounted a well-funded campaign to control the disease. To date, 64 767 people have been vaccinated, 150 000 farms and houses have been sprayed with insecticide, and an active programme of health education and social mobilization has been mounted in affected areas. In addition, the Government intends to destroy more than 300 000 pigs as a means of eliminating the source of the virus.
WHO has been monitoring the situation and has been in regular contact with the Malaysian Ministry of Health since early in the outbreak through its office in Kuala Lumpur. The Regional Office in Manila has provided technical advice, including information on JE vaccines.
The WHO Collaborating Centre for Arbovirus Reference and Research at the Department of Medical Microbiology of the University of Malaya in Kuala Lumpur has been at the forefront of the virological investigation of the current outbreak. Another WHO Collaborating Centre at the Institute for Tropical Medicine, Nagasaki University, Nagasaki, Japan has also been carrying out serological confirmation on samples from Malaysia.
Two international teams, one from the United States of America and the other from Australia are now in Kuala Lumpur to help investigate the outbreak. Their role will be to carry out detailed serological and virological investigations that will provide a clearer picture of the dynamics of the current outbreak.
WHO fully supports the control efforts being taken by the Malaysian Ministry of Health and is ready to provide technical advice and mobilize additional international resources to help control the current outbreak.