EAOP Architecture Description

The architecture of the EAOP tool is composed of the following parts:

• Events: Execution points are represented by event objects. This distribution of the EAOP tool includes a library currently providing method call/return and constructor call/return events.
• Aspects and aspect composers: The EAOP tool includes an OO framework for the definition of aspects and aspect composers. An aspect can be basic (i.e. it subclasses the class fr.emn.info.eaop.Aspect and implements the method definition) or it can be composed from basic aspects and aspect composers. This distribution contains aspect composers for sequencing and prioritization of aspects as well as conditional execution of aspects.
  Furthermore, aspect composers (not only aspects) can be defined by users (for an example have a look at the sources in directory examples/cflow/src which illustrates how to define AspectJ-like cflow operators using EAOP.
• Monitor: When an event is generated, the program calls the monitor (the program and the monitor are coroutines) with the current event as a parameter. the monitor wakes up all aspects in turn with the current event as a parameter (the aspects are coroutines, only one aspect is executing at a time). Aspects form a directed acyclic graph (DAG) the nodes of which limit/specify the propagation of the events to the different basic aspects. The monitor and the aspects are event transformers (e.g. aspects can modify the value of the arguments of a method call represented by an event). Such modifications are applied when control returns from the monitor execution, i.e., before the program execution resumes.
• Instrumentation: Insertion of event construction statements and calls to the monitor by source-code transformation. Source instrumentation can be applied selectively with fine grain.