This interface defines all the methods that perform program
instrumentations that are useful for AOP.
The modifications definitions rely on an abstract representation
of locators, as defined in the
org.aopalliance.reflect
package.
addAfterCode
public Instrumentation addAfterCode(CodeLocator location,
Code afterCode,
Instrumentation before,
Instrumentation after)
throws InstrumentationError
Adds some code after a given method code body.
location
- the modification locator that can represent a
method invocation, a field set/get, or a constructor (at callee
or caller side)afterCode
- the code to be added afterbefore
- the modification that must stay before this
after codeafter
- the modification that must stay after this
after code
- the object that corresponds to this instrumentation
addAroundCode
public Instrumentation addAroundCode(CodeLocator location,
Code aroundCode,
String proceedMethodName,
Instrumentation before,
Instrumentation after)
throws InstrumentationError
Adds some code around a given method code body.
An around code is a code that calls a
proceed method
one or several times. When the proceed method is invoked, the
location is executed (for compile approched, the proceed method
call is subsituted by the location).
The proceed method name is parameterized by the
proceedMethodName
argument (can be
proceed
,
invokeNext
,
runNext
, etc).
Note that if the around code does not call the proceed
method, then the around instrumentation is similar to a
replacement of the location. This is not aspect-safe but can be
useful in some instrumentation process to build AO systems.
location
- the modification locator that can represent a
method invocation, a field set/get, or a constructor (at callee
or caller side)aroundCode
- the code to be added afterproceedMethodName
- the name of the proceed methodbefore
- the modification that must stay before this
after codeafter
- the modification that must stay after this
after code
- the object that corresponds to this instrumentation
addBeforeCode
public Instrumentation addBeforeCode(CodeLocator location,
Code beforeCode,
Instrumentation before,
Instrumentation after)
throws InstrumentationError
Adds some code before a given method code body.
location
- the modification locator that can represent a
method invocation, a field set/get, or a constructor (at callee
or caller side)beforeCode
- the code to be added beforebefore
- the modification that must stay before this
before codeafter
- the modification that must stay after this
before code
- the object that corresponds to this instrumentation
addClass
public Instrumentation addClass(ClassLocator location,
String className)
throws InstrumentationError
Introduces a class into the class location (mixin).
Similarely to a mixin, the whole set of fields and methods
are introduced into the location's class, all the implemented
interface of the introduced class are also added as interfaces
of the location's class.
- the object that corresponds to this instrumentation
addInterface
public Instrumentation addInterface(ClassLocator location,
String newInterfaceName)
throws InstrumentationError
Adds a new implemented interface to a given class location.
- the object that corresponds to this instrumentation
addMethod
public Instrumentation addMethod(ClassLocator location,
String name,
String[] parameterTypeNames,
String[] parameterNames,
Code body)
throws InstrumentationError
Adds a new method to the class location.
- the object that corresponds to this instrumentation
createClass
public ClassLocator createClass(String name)
throws InstrumentationError
Creates a new class.
- the locator that corresponds to the newly created class
setSuperClass
public Instrumentation setSuperClass(ClassLocator location,
String newSuperClassName)
throws InstrumentationError
Sets or replaces the current superclass of a class location.
The new superclass should be a subtype of the replaced one in
order to maintain backward compatibility.
- the object that corresponds to this instrumentation