2 Basic Concepts
2.1 Pointcuts
Aspects in AspectC++ implement crosscutting concerns in a modular way. With this in mind the most important element of the AspectC++ language is the pointcut. Pointcuts describe a set of join points by determining on which condition an aspect shall take effect. Thereby each join point can either refer to a function, a type/class, a variable, or a point from which a join point is accessed so that this condition can be for instance the event of reaching a designated code position or the allocation of a variable with a certain value. Depending on the kind of pointcuts, they are evaluated at compile time or at runtime.
2.1.1 Match Expressions
There are two types of pointcuts in AspectC++: code pointcuts and name pointcuts. Name pointcuts describe a set of (statically) known program entities like types/classes, variables, functions, or namespaces. All name pointcuts are based on match expressions. A match expression can be understood as a search pattern. In such a search pattern the special character “%” is interpreted as a wildcard for names or parts of a signature. The special character sequence “…” matches any number of parameters in a function signature or any number of scopes in a qualified name. A match expression is a quoted string.
Example: match expressions (name pointcuts)
- "int C::%(...)"
-
matches all member functions of the class C that return an int - "%List"
-
matches any namespace, class, struct, union, or enum whose name ends with List. In case of a matched namespace or class the match expression also matches entities inside the namespace resp. class. For more information see section 3.2. - "%
- printf(const char *, ...)"
matches the function printf (defined in the global scope) having at least one parameter of type const char * and returning any type - "const %& ...::%(...)"
-
matches all functions that return a reference to a constant object
2.1.2 Pointcut Expressions
The other type of pointcuts, the code pointcuts, describe an intersection through the set of the points in the control flow of a program. A code pointcut can refer to a call or execution point of a function, to a call of a built-in operator or and to write and read points of member variables and global variables. They can only be created with the help of name pointcuts because all join points supported by AspectC++ require at least one name to be defined. This is done by calling predefined pointcut functions in a pointcut expression that expect a pointcut as argument. Such a pointcut function is for instance within(pointcut), which filters all join points that are within the functions or classes in the given pointcut.
Name and code pointcuts can be combined in pointcut expressions by using the algebraic operators “&&”, “||”, and “!”.
Example: pointcut expressions
- "%List" && !derived("Queue")
-
describes the set of classes with names that end with “List” and that are not derived from the class Queue - call("void
- draw()") && within("Shape")
describes the set of calls to the function draw that are within methods of the class Shape
2.1.3 Types of Join Points
According to the two types of pointcuts supported by AspectC++ there are also two coarse types of join points: name join points and code join points. As diagramed in figure 1 both of these have sub join point types. The types Any, Name, Code and Access are abstract types and exist just for categorizing the other join point types.
Figure 1 is extracted from the AspectC++ project repository hierarchy, that can be found in appendix C.
Figure 1 is extracted from the AspectC++ project repository hierarchy, that can be found in appendix C.
Based on a short code fragment the differences and relations between the types of join points shall be clarified.
class Shape { /*...*/ };
void draw(Shape& shape) { /*...*/ }
namespace Circle {
typedef int PRECISION;
class S_Circle : public Shape {
PRECISION m_radius;
public:
void radius(PRECISION r) {
m_radius = r;
}
~S_Circle() { /*...*/ }
};
void draw(PRECISION r) {
S_Circle circle;
circle.radius(r);
draw(circle);
}
}
int main() {
Circle::draw(10);
return 0;
}Code join points are used to form code pointcuts and name join points (i.e. names) are used to form name pointcuts. Figure 2 shows join points of the code fragment above and how they correlate. Built-in constructors, destructors and uncalled operators are not shown. Additionally appendix D shows the contents of the project repository
3
for the code fragment.The AspectC++ project repository is a file, that contains the internal AspectC++ model as xml-tree. The actual style and format of the content may change at any time. For more information see the AspectC++ Compiler Manual.
Every execution join point is associated with the name of an executable function. Pure virtual functions are not executable. Thus, advice code for execution join points would never be triggered for this kind of function. However, the call of such a function, i.e. a call join point with this function as target, is absolutely possible. Furthermore there are no execution join points for built-in operator functions.
Every call or builtin join point is associated with two names: the name of the source and the target function (in case of builtin this is the global built-in operator function) of a function call. As there can be multiple function calls within the same function, each function name can be associated with a list of call join points and builtin join points. The same holds for set and get join points, which represent write resp. read operations on data members or global variables. Each of these join points is associated with the name of the function that contains the join point and the name of the accessed member variable or global variable. A construction join point means the class specific instruction sequence executed when an instance is created. In analogy, a destruction join point means the object destruction.
2.1.4 Pointcut declarations
AspectC++ provides the possibility to name pointcut expressions with the help of pointcut declarations. This makes it possible to reuse pointcut expressions in different parts of a program. They are allowed where C++ declarations are allowed. Thereby the usual C++ name lookup and inheritance rules are also applicable for pointcut declarations.
A pointcut declaration is introduced by the keyword pointcut.
Example: pointcut declaration
- pointcut lists() = derived("List");
-
lists can now be used everywhere in a program where a pointcut expression can be used to refer to derived("List")
Furthermore pointcut declarations can be used to define pure virtual pointcuts. This enables the possibility of having re-usable abstract aspects that are discussed in section 2.5. The syntax of pure virtual pointcut declarations is the same as for usual pointcut declarations except the keyword virtual following pointcut and that the pointcut expression is “0”.
Example: pure virtual pointcut declaration
- pointcut virtual methods() = 0;
-
methods is a pure virtual pointcut that has to be redefined in a derived aspect to refer to the actual pointcut expression
2.2 Attributes
Based on the C++11 attribute syntax AspectC++ provides an annotation mechanism for join points
4
. All join points annotated with the same attribute “a”, e.g. class [[a]] C {…}, can be referred to in a pointcut expression as a(). Further information can be found in section 5.In other languages this mechanism is known as “annotations”.
2.3 Slices
A slice is a fragment of a C++ language element that defines a scope. It can be used by advice to extend the static structure of the program. For example, the elements of a class slice can be merged into one or more target classes by introduction advice. The following example shows a simple class slice declaration.
Example: class slice declaration
slice class Chain {
Chain *_next;
public:
Chain *next () const { return _next; }
};
2.4 Advice Code
To a code join point so-called advice code can be bound. Advice code can be understood as an action activated by an aspect when a corresponding code join point in a program is reached. The activation of the advice code can happen before, after, or before and after the code join point is reached. The AspectC++ language element to specify advice code is the advice declaration. It is introduced by the keyword advice followed by a pointcut expression defining where and under which conditions the advice code shall be activated.
Example: advice declaration
advice execution("void login(...)") : before() {
cout << "Logging in." << endl;
}
The code fragment :before() following the pointcut expression determines that the advice code shall be activated directly before the code join point is reached. It is also possible here to use :after() which means after reaching the code join point respectively :around() which means that the advice code shall be executed instead of the code described by the code join point. In an around advice the advice code can explicitly trigger the execution of the program code at the join point so that advice code can be executed before and after the join point. There are no special access rights of advice code regarding to program code at a join point.
Beside the pure description of join points pointcuts can also bind variables to context information of a join point. Thus for instance the actual argument values of a function call can be made accessible to the advice code.
Example: advice declaration with access to context information
pointcut new_user(const char *name) =
execution("void login(...)") && args(name);
advice new_user(name) : before(const char *name) {
cout << "User " << name << " is logging in." << endl;
}
In the example above at first the pointcut new_user is defined including a context variable name that is bound to it. This means that a value of type const char* is supplied every time the join point described by the pointcut new_user is reached. The pointcut function args used in the pointcut expression delivers all join points in the program where an argument of type const char* is used. Therefore args(name) in touch with the execution join point binds name to the first and only parameter of the function login.
The advice declaration in the example above following the pointcut declaration binds the execution of advice code to the event when a join point described in new_user is reached. The context variable that holds the actual value of the parameter of the reached join point has to be declared as a formal parameter of before, after, or around. This parameter can be used in the advice code like an oridinary function parameter.
Beside the pointcut function args the binding of context variables is performed by that, target, and result. At the same time these pointcut functions act as filters corresponding to the type of the context variable. For instance args in the example above filters all join points having an argument of type const char*.
2.4.1 Introductions
The second type of advice supported by AspectC++ are the introductions. Introductions are used to extend program code and data structures in particular. The following example extends two classes each by a member variable and a member function.
Example: introductions
pointcut shapes() = "Circle" || "Polygon";
advice shapes() : slice class {
bool m_shaded;
void shaded(bool state) {
m_shaded = state;
}
};
Like an ordinary advice declaration an introduction is introduced by the keyword advice. If the following pointcut is a name pointcut the slice declaration following the token “:” is introduced in the classes and aspects described by the pointcut. Introduced code can then be used in normal program code like any other member function, member variable, etc. Advice code in introductions has full access rights regarding to program code at a join point, i.e. a method introduced in a class has access even to private members of that class.
Slices can also be used to introduce new base classes. In the first line of the following example it is made sure that every class with a name that ends with “Object” is derived from a class MemoryPool. This class may implement an own memory management by overloading the new and delete operators. Classes that inherit from MemoryPool must redefine the pure virtual method release that is part of the implemented memory management. This is done in the second line for all classes in the pointcut.
Example: base class introduction
advice "%Object" : slice class : public MemoryPool {
virtual void release() = 0;
}
2.4.2 Advice Ordering
If more than one advice affects the same join point it might be necessary to define an order of advice execution if there is a dependency between the advice codes (“aspect interaction”). The following example shows how the precedence of advice code can be defined in AspectC++.
Example: advice ordering
advice call("% send(...)") : order("Encrypt", "Log");
2.5 Aspects
The aspect is the language element of AspectC++ to collect introductions and advice code implementing a common crosscutting concern in a modular way. This put aspects in a position to manage common state information. They are formulated by means of aspect declarations as a extension to the class concept of C++. The basic structure of an aspect declaration is exactly the same as an usual C++ class definition, except for the keyword aspect instead of class, struct or union. According to that, aspects can have member variables and member functions and can inherit from classes and even other aspects.
Example: aspect declaration
aspect Counter {
static int m_count;
pointcut counted() = "Circle" || "Polygon";
advice counted() : slice struct {
class Helper {
Helper() { Counter::m_count++; }
} m_counter;
};
advice execution("% main(...)") : after() {
cout << "Final count: " << m_count << " objects"
<< endl;
}
};
... and at an appropriate place
#include "Counter.ah"
int Counter::m_count = 0;
In this example the count of object instantiations for a set of classes is determined. Therefore, a member variable m_counter is introduced into the classes described by the pointcut incrementing a global counter on construction time. By applying advice code for the function main the final count of object instantiations is displayed when the program terminates.
This example can also be rewritten as an abstract aspect that can for instance be archived in an aspect library for the purpose of reuse. It only require to reimplement the pointcut declaration to be pure virtual.
Example: abstract aspect
aspect Counter {
static int m_count;
Counter() : m_count(0) {}
pointcut virtual counted() = 0;
...
};
It is now possible to inherit from Counter to reuse its functionality by reimplementing counted to refer to the actual pointcut expression.
Example: reused abstract aspect
aspect MyCounter : public Counter {
pointcut counted() = derived("Shape");
};
2.5.1 Aspect Instantiation
By default aspects in AspectC++ are automatically instantiated as global objects. The idea behind it is that aspects can also provide global program properties and therefore have to be always accessible. However in some special cases it may be desired to change this behavior, e.g. in the context of operating systems when an aspect shall be instantiated per process or per thread.
The default instantiation scheme can be changed by defining the static method aspectof resp. aspectOf that is otherwise generated for an aspect. This method is intended to be always able to return an instance of the appropriate aspect.
Example: aspect instantiation using aspectof
aspect ThreadCounter : public Counter {
pointcut counted() = "Thread";
advice counted() : ThreadCounter m_instance;
static ThreadCounter *aspectof() {
return tjp->target()->m_instance;
}
};
The introduction of m_instance into Thread guarantees that every thread object has an instance of the aspect. By calling aspectof it is possible to get this instance at any join point which is essential for accessing advice code and members of the aspect. For this purpose code in aspectof has full access to the actual join point in a way described in the next section.
2.6 Runtime Support
2.6.1 Support for Advice Code
For many aspects access to context variables may not be sufficient to get enough information about the join point where advice code was activated. For instance a control flow aspect for a complete logging of function calls in a program would need information about function arguments and its types on runtime to be able to produce a type-compatible output.
In AspectC++ this information is provided by the members of the class JoinPoint available both in advice code and introductions (see table below).
| types: | |
| Result | result type |
| That | object type |
| Target | target type |
| AC::Type | encoded type of an object |
| AC::JPType | join point types |
| static methods: | |
| int args() | number of arguments |
| AC::Type type() | type of the function or attribute |
| AC::Type argtype(int) | types of the arguments |
| const char *signature() | signature of the function or variable |
| unsigned id() | identification of the join point |
| AC::Type resulttype() | result type |
| AC::JPType jptype() | type of join point |
| non-static methods: | |
| void *arg(int) | actual argument |
| Result *result() | result value |
| That *that() | object referred to by this |
| Target *target() | target object of a call |
| void proceed() | execute join point code |
| AC::Action &action() | Action structure |
Table 1: API of class JoinPoint available in advice code
Types and static methods of the JoinPoint API deliver information that is the same for every advice code activation. The non-static methods deliver information that differ from one activation to another. These methods are accessed by the object tjp resp. thisJoinPoint which is of type JoinPoint and is always available in advice code and introductions, too.
The following example illustrates how to implement a re-usable control flow aspect using the JoinPoint API.
Example: re-usable trace aspect
aspect Trace {
pointcut virtual methods() = 0;
advice execution(methods()) : around() {
cout << "before " << JoinPoint::signature() << "(";
for (unsigned i = 0; i < JoinPoint::args(); i++)
printvalue(tjp->arg(i), JoinPoint::argtype(i));
cout << ")" << endl;
tjp->proceed();
cout << "after" << endl;
}
};
This aspect weaves tracing code into every function specified by the virtual pointcut redefined in a derived aspect. The helper function printvalue is responsible for the formatted output of the arguments given at the function call. After calling printvalue for every argument the program code of the actual join point is executed by calling proceed on the JoinPoint object. The functionality of proceed is achieved by making use of the so-called actions.
2.6.2 Actions
In AspectC++ an action is the statement sequence that would follow a reached join point in a running program if advice code would not have been activated. Thus tjp->proceed() triggers the execution of the program code of a join point. This can be the call or execution of a function as well as the writing or reading of member variables or global variables. The actions concept is realized in the AC::Action structure. In fact, proceed is equivalent to action().trigger() so that tjp->proceed() may also be replaced by tjp->action().trigger(). Thereby the method action() of the JoinPoint API returns the actual action object for a join point.
2.6.3 Support for Introductions
The JoinPoint API available in code introduced by an introduction is listed in the following table.
| static methods: | |
| const char *signature() | signature of the function or member variable |
| unsigned id() | identification of the join point |
| AC::JPType jptype() | type of join point |
| types: | |
| Aspect | type of the aspect |
Table 2: JoinPoint API for introductions
In difference to the API available for advice code the API for introduction only provides static information about a join point. A nice demonstration of this API is shown in the following example.
Example: static type identification using introductions
aspect TypeInfo {
pointcut virtual typed() = 0;
advice typed() : static unsigned type_id() {
return JoinPoint::id();
}
advice typed() : virtual unsigned type() {
return type_id();
}
};
The first introduction of this aspect introduces a static method type_id into a set of classes returning an unique integer value. By introducing a second non-static but virtual method type into these classes also returning the unique integer value a type identification can be realized like this:
if (obj->type() == AClass::type_id())
...
else if (obj->type() == AnotherClass::type_id())
...
This implements a nice alternative to the C++ RTTI mechanism especially when the RTTI support of a compiler is switched off.
Code of introductions have to use the type Aspect to get access to the methods and member variables of an aspect, e.g. by calling Aspect::aspectof(). Because the static function aspectof is always generated for an aspect, except when it is already explicitly defined, aspectof always returns the actual aspect instance. By courtesy of this technique the example elsewhere can be changed to provide not only the count of all threads but to provide a count for every thread.
Example: extended thread counting
aspect Counter {
int m_count;
...
advice counted() : class Helper {
Helper() { Aspect::aspectof()->m_count++; }
} m_counter;
...
};
