class A {

  @Cachable
  public B lazyMethod() {
    return new B();
  }

}

public aspect CachingAspect {

	MethodCache methodCache = new MethodCache();
	WeakLockRepository lockRepo = new WeakLockRepository();
        LockRepository<Object> objectLockRepository = new LockRepository<Object>();

	Object around(): execution(* *(..)) && @annotation(org.openmole.commons.aspect.caching.Cachable) {
		
		Object object = thisJoinPoint.getThis();
		String method = thisJoinPointStaticPart.getSignature().toString();

		Object ret = methodCache.getCachedMethodResult(object, method);
		
		if(ret !=  null) return ret;

		Lock lock = lockRepo.getLockFor(object, method);

		lock.lock();
		try {		
			objectLockRepository.lock(object);

                        try{
                            ret = methodCache.getCachedMethodResult(object, method);
                            if(ret == null) {
				ret = proceed();
				methodCache.putCachedMethodResult(object, method, ret);
                            }
                            return ret;
                        } finally {
                            objectLockRepository.unlock(object);
                        }
			
		} finally {
			lock.unlock();
		}
	}

        before() : execution(* *(..)) && @annotation(org.openmole.commons.aspect.caching.ChangeState) {
             Object object = thisJoinPoint.getThis();
             objectLockRepository.lock(object);

              try {
                methodCache.clear(object);
                softMethodCache.clear(object);
             } finally {
		objectLockRepository.unlock(object);
             }
  	}
}