< Back
Release Notes v0.7.0
What's new?
Aspects
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.*.*(..)) {
System.out.println(msg);
}
}
/* 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;
doSomething();
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.
