[aspectj-users] Use Cases for Changing target and this in proceed

[Curtis Clifton <curt.clifton@xxxxxxx>]

I am trying to understand the semantics of proceed.  One interesting 
issue arises because AspectJ lets us change the "this" and "target" 
objects when proceeding from around advice.  Here's a fragment that 
just changes the "this" object (the full code for the example is given 
below):

	void around(ChangeThis th) : call(* *.m()) && this(th) {
		System.out.println("first around call m: this = " + th);
		proceed(new ChangeThis()); // change this, just seen in subsequent 
advice
		System.out.println("first around call m: this = " + th);
	}

My example isn't practical; it is just meant to demonstrate the 
semantic issue.

My question is about use cases for changing the target and this objects 
when proceeding.  I can imagine wanting to change the target object: 
perhaps we want to wrap the original target in some wrapper object 
before proceeding.  However, I haven't been able to come up with a 
realistic use case for changing the "this" object.  I assume changing 
the "this" object would only affect join point information bound in 
subsequent advice.  I don't see how it could change the original "this" 
object that called the advised code, and the advised code wouldn't 
typically be able to determine its original caller. (Experimentation 
with ajc version 1.2 bears this assumption out.)  Also, it also isn't 
clear what it should mean to change the target object at an execution 
join point, because presumably the target object's stack frame has 
already been pushed.

My basic question is:

Are there any use cases for changing the "this" object in a proceed?  
Or is this capability just a result of the decision to make the 
arguments to proceed match the parameters of the surrounding advice?

Thanks for any insight,

Curt

----------------------------------
Curtis Clifton, PhD Candidate
Dept. of Computer Science, Iowa State University
http://www.cs.iastate.edu/~cclifton

// Full sample code
public class ChangeThis {
	private B b = new B();

	public static void main(String[] args) {
		new ChangeThis().run();
	}
	
	void run() {
		System.out.println("in run, with b = " + b);
		b.m();
		System.out.println("in run, with b = " + b);
	}
	
}

class B {
	void m() {
		System.out.println("in m, this = " + this);
	}
}

aspect Asp1 {
	void around(ChangeThis th) : call(* *.m()) && this(th) {
		System.out.println("first around call m: this = " + th);
		proceed(new ChangeThis()); // change this, just seen in subsequent 
advice
		System.out.println("first around call m: this = " + th);
	}

	void around(ChangeThis th) : call(* *.m()) && this(th) {
		System.out.println("second around call m: this = " + th);
		proceed(th); // change this, seen in next advice?
		System.out.println("second around call m: this = " + th);
	}
}