Features of AOP languages

• AOP languages have the following main elements: – a join point model (JPM) wrt base PL

– a specification language for expressing sets of join points (JPS)

– a means of specifying behavior involving join points (BJP)

– encapsulated units combining JPS and BJP (CSB)

– method of attachment of units to base program (AU)

Comparing

• AspectJ

• DemeterJ

• DJ

• ATC

• AspectC

AspectJ JPM

• principled points of execution– message sends (basically a method call),

message receptions, method executions– field references (get and set)– exception throwing and handling– constructor execution

• which context is available at each join point?

AspectJ JPS

• pointcut designators– primitive: calls(sig), receptions(sig), executions(sig),

instanceof(type), within(type), cflow(pcd), getter(sig?), setter(sig?)

– operators: &&, ||, !

• can name a pointcut and expose context– pointcut foo (V v):pcd (using v);

• pointcut maybe abstract (declaration) and defined in a subaspect.

AspectJ BJP

• before, after, around: a pointcut.

• can refer to thisJoinPoint– explain join point object:

• instance of JoinPoint class. Interface: getSignature(), getActualParameters(),…

• JoinPoint has eleven subclasses: CallJoinPoint, ReceptionJoinPoint, ExecutionJoinPoint, ExceptionJoinPoint, …

• in around (instead of) can say: proceed()

AspectJ CSB

• an aspect contains a list of advice and point cut declarations and introductions and regular fields and methods.

Explaining aspect instance

• when you declare an aspect, you say either of eachJVM() or of eachobject(pcd)

• logging: log stream put in aspect instance of each VM (one instance for whole program)

• dft: mark field put it in aspect instance of each object (node object of the graph)

AspectJ AU

• ajc takes a list of files: aspects and classes and weaves them together.

DemeterJ JPM

• traversal method calls on Java object, constructor calls

DemeterJ JPS

• strategies

– define family of traversal programs to be enhanced

– approximation: function mapping object graphs to subgraphs

• sentences

– define family of Java objects: executions of constructor calls

DemeterJ BJP

• visitor classes– before *

DemeterJ CSB

• adaptive methods– void f() to S (V1, V2)

DemeterJ AU

• make new .beh file, add to .prj file, demeterj

DJ JPM

• object graph : nodes and edges

• principled points: traversal of nodes or edges

• fix a traversal algorithm

DJ JPS

• strategies

– define family of traversal programs to be enhanced

– approximation: function mapping object graphs to subgraphs (object graph slices)

DJ BJP

• visitor classes– before(A a), after(C c), cbefore_x(Object a,

Object b), caround_x(Object a, Object b, Subtraverser st)

– each method applies to a different part of the point cut (strategy)

DJ CSB

• aspectual methodsvoid f(ClassGraph cg) {

cg.traverse(this,

“from A to S”,

new Visitor() {…});}

DJ AU

• add methods to classes

DJ: Second view: Doug

DJ JPM

• object graph slices: nodes and edges

• fix a traversal algorithm

DJ JPS

• strategies

– define family of traversal programs to be enhanced

– approximation: function mapping object graphs to subgraphs (object graph slices)

• in addition: visitor methods are pointcut designators

• pointcut designators are encoded in signatures of visitor methods

DJ BJP

• visitor classes– each visitor method is advice on the point cut

specified by the method signature

DJ CSB

• a visitor class is a package of advice

• when you use a visitor in a traversal of an ogs (in traverse) then each pointcut is intersected with the traversal pointcut, namely cflow(traverse). (can also use within)

DJ AU

• to attach an aspect you call traverse with an aspect (visitor).

• traverse expression attaches the aspect to an object graph slice.

AspectC JPM

• function calls, variable references

• data available: args to function calls

AspectC JPS

• point cut designators– call (foo( c )): all calls of function foo with one

argument

– cflow( any point cut designator): “whatever comes afterwards on the stack”

– varref(name)

– combine with && , || and !

AspectC BJP

• before, after, around

AspectC CSB

• are hardwired together: when advice is given, you need to give point cut

AspectC AU

• concatenated to the source

ATC JPMAspects in Tiny CLOS

• generic function receptions, method executions

• use MOP to implement aspects

• what data is exported: see join point object

ATC JPS !

• point cut designators– predicate on aspect instance and join point object

– explain join point object:• instance of <join-point> class. Interface: slots: generic (generic

function being called), args (actual parameters), stack (stack of join points in current control flow)

• <join-point> has two subclasses: <reception-join-point> and <execution-join-point>

• <execution-join-point> has additional slot: method (being executed)

• (all the traversal methods in the cflow of the first traversal call)

ATC BJP

• before, after, around: take aspect instance and join point object as argument.

• around has third arg: continuation

• generic function ...

ATC CSB

• advice has a pointcut generic function (like an abstract pointcut in AspectJ). Methods of generic function are specified separately.

• an aspect contains a list of advice (no point cut declaration)

• an aspect is an instance of <aspect>

Explaining aspect instance

• class <aspect> has two subclasses: <aspect-of-each-vm> <aspect-of-each-object >

• logging: log stream put in aspect instance of each VM (one instance for whole program)

• dft: mark field put it in aspect instance of each object (node object of the graph)

ATC AU !

• <aspectizable> mixin: has slot aspects: holds list of attached aspects

• <aspectizable-generic> is a subclass of both <generic> and <aspectizable> (<generic> is the class of all generic functions)

• add-aspect! , remove-aspect!

• all generic functions in base program are aspectizable (non-obliviousness ok)

Aspectual Collaborations JPM

• principled points of execution– abstract join points that are mapped by the

adapter to concrete ones– execution of methods modified by collaboration

• enhance the class graph: open classes: add more members to existing classes

• which context is available at each join point?

Aspectual Collaborations JPS

• sets of join points: collaboration + adapter (in the adapters we express the cross cutting)

• collaboration roles only: have the flavor of an abstract pointcut.

Aspectual Collaborations BJP

• before, after, around: for methods

• can refer to actual parameters

• in replace (around (instead of)) can say: expected()

Aspectual Collaborations CSB

• collaborations and adapters

Aspectual Collaborations AU

• ac-compiler (non existent) takes a list of files: classes and collaborations and adapters and weaves them together.

Using AspectJ to implement collaborations/adapters

• AspectJ can only express the adapted collaborations

• AspectJ supports interfaces with full methods and multiple inheritance

Goal

• Input: classes, collaborations, adapters

• Output: AspectJ code