* Programming Guide * CJDT User Guide * Publications * Tutorial * Language Spec.



Source Code


Community Info

About Us


ST Logo
TUD Logo
< Back

Release Notes v0.7.0

What's new?


AspectJ weaver is upgraded from 1.1 to 1.2, what significantly reduces compilation time.

Pointcuts and advice are completely integrated into CaesarJ inheritance semantics, i.e. pointcuts and advice can be inherited from different parents. Named pointcuts can be overridden (both concrete and abstract). Conflicting situations, when several pointcuts are inherited with the same name, are resolved by linearization rules.

An example of using pointcuts with mixin composition:
abstract public cclass Tracer {
    abstract pointcut traceMethods();  
abstract public cclass ConsoleTracer extends Tracer {
    before() : traceMethods() {
        System.out.println("Entering [" + thisJoinPointStaticPart.toString() + "]");
    after() : traceMethods() {
        System.out.println.println("Leaving [" + thisJoinPointStaticPart.toString() + "]");
abstract public cclass AbstractModelTracer extends Tracer {
    pointcut traceMethods() : execution(* model.*.*(..)) || execution(model.*.new(..)); 
public deployed cclass ModelConsoleTracer extends AbstractModelTracer & ConsoleTracer {

aspect() method is provided for deployed classes to access the statically deployed instance:
deployed public cclass MyAspect {
   private msg = "Undef";
   public void setMsg(String str) {
       msg = str;
   after() : execution(* mypckg.*.*(..)) {

/* code from outside */
MyAspect.aspect().setMsg("Hello world");

Simple aspect deployment (deployment on entire JVM process) is available through deploy and undeploy statements:
MyAspect asp = new MyAspect();
deploy asp;
undeploy asp;

Minor optimizations of aspect deployment, especially for the case when single instance is deployed.

Removed Limitations

Constructors with parameters in cclass are allowed. They can be used for initialization of final fields.

Abstract pointcuts are allowed.

Access to static fields and static methods declared in cclass is allowed.

More tolerant mixin composition rules are used that allow mixing classes with conflicting mixin order, for example:
public cclass A {
public cclass B {
public cclass C extends A & B {
public cclass D extends B & A {
public cclass E extends C & D {  // order of A and B is conflicting
}                                // order defined in C dominates

Inheritance from implicit virtual classes is allowed, for example:
public cclass A {
   public cclass InnerA {
public cclass B extends A {
   public cclass InnerB extends InnerA { // InnerA is implicit

Dependent types can be used in wraps relationship:
public cclass A {
   public cclass X {
public cclass B {
   public final A a = new A();
   public cclass Y wraps a.X { // wraps dependent type 

Wrappees can be now accessed outside the wrapper object:
public class A {
   public void m() {
public cclass B {
   public cclass Y wraps A {

/* code from outside */
A a = new A();
final B b = new B();
b.Y y = b.Y(a);
y.wrappee.m();  // access wrappee of y

Important Bug fixes

A lot of problems related with dependent types are solved.

Pointcut references are correctly resolved.

Aspect precedence declarations are fixed.

CJDT Plugin for Eclipse

Outline (including crosscutting view) is stabilized.

Generated class members are hidden.

Basic support for debugging.

Known limitations

  • There are certain visibility restrictions:
    • package visibility is not available.
    • cclass'es must be declared as public.

  • public fields can be only written by the owner object, access from outside is read-only

  • Arrays of cclass-es are not allowed.

  • It is not possible for Caesar classes to inherit from pure Java classes. Nevertheless Caesar classes can implement Java interfaces.

  • Pointcut language cannot refer to Caesar type system but rather to the underlying generated Java classes and interfaces.

  • Default constructor is always available. Classes inherit constructors from they parents. Inherited constructors can be overridden, but not hidden.