Description jody brownell 2006-02-10 12:53:51 EST

I have created a simple test Aspect which advises methods which are annotated with @Lock.Read and @Lock.Write when belonging to a type annotated with @Lock.

When debugging, I noticed that ALL classes in my eclipse project had been instrumented with extraneous fields interface's (fields / methods) even though they were not annotated with the required annotations for the aspect to advise them.

The orginal PCD which worked but caused all classes to be instrumented (but not advised) was

	pointcut readLock(): execution(@Lock.Read * * (..));
	pointcut writeLock(): execution(@Lock.Write * * (..));

When changing these definitions to 

	pointcut readLock(): execution(@Lock.Read * (@Lock *).*(..));
	pointcut writeLock(): execution(@Lock.Write * (@Lock *).*(..));

only classes annotated with @Lock on the type and @Lock.Read/Write on methods were actually instrumented. This was the desired result. Both work equally well at runtime but the orginal pcd will cause all classes to have placeholder fields and extraneous methods (as per $ajcMighHaveAspect?) even though they will _never_ be advised. 


The aspect: 

import java.util.concurrent.locks.ReentrantReadWriteLock;

public abstract aspect LockAspect pertarget(fair(Lock) && (readLock() ||
writeLock()))
{
	declare error: execution(@Lock.Read * * (..)) && !@within(Lock):

		"@Lock.Read and @Lock.Write cannot be used unless the Class/Interface is annotated with @Lock"; 
	
	private ReentrantReadWriteLock.ReadLock read;
	private ReentrantReadWriteLock.WriteLock write;
	private ReentrantReadWriteLock lock;

	public LockAspect(boolean fair)
	{
		lock = new ReentrantReadWriteLock(fair);
		
		read = lock.readLock();
		write = lock.writeLock();
	}
	
	abstract pointcut fair(Lock lock);

// fixed pcd
//	pointcut readLock(): execution(@Lock.Read * (@Lock *).*(..));
//	pointcut writeLock(): execution(@Lock.Write * (@Lock *).*(..));

// broken? pcd
	pointcut readLock(): execution(@Lock.Read * * (..));
	pointcut writeLock(): execution(@Lock.Write * * (..));
	
	Object around(): readLock()
	{
		Object o = null;

		try
		{
			read.lock();
			o = proceed();
		}
		finally
		{
			read.unlock();
		}

		return o;
	}

	Object around(): writeLock()
	{
		Object o = null;

		try
		{
			write.lock();
			o = proceed();
		}
		finally
		{
			write.unlock();
		}

		return o;
	}
}

aspect UnfairLockAspect extends LockAspect
{
	pointcut fair(Lock lock): @within(lock) && if(lock.isFair() == false);
	
	public UnfairLockAspect()
	{
		super(false);
	}
}

aspect FairLockAspect extends LockAspect
{
	pointcut fair(Lock lock): @within(lock) && if(lock.isFair() == true);
	
	public FairLockAspect()
	{
		super(true);
	}
}
The annotation:

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Lock
{
	/**
	 * Whether the locks granted are being granted in a fair manner.
	 * 
	 * @return if the lock associated with this object is fair or not.
	 * @see java.util.concurrent.locks.ReentrantReadWriteLock#ReentrantReadWriteLock(boolean)
	 */
	public boolean isFair() default false;

	/**
	 * Mark a method as having a read lock
	 */
	@Documented
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.METHOD)
	public @interface Read
	{
	}

	/**
	 * Mark a method as having a write lock
	 */
	@Documented
	@Retention(RetentionPolicy.RUNTIME)
	@Target(ElementType.METHOD)
	public @interface Write
	{
	}
}