org.aspectj.lang.ProceedingJoinPoint Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjrt Show documentation
The runtime needed to execute a program using AspectJ
There is a newer version: 1.9.22.1
/*******************************************************************************
 * Copyright (c) 2005 Contributors.
 * All rights reserved.
 * This program and the accompanying materials are made available
 * under the terms of the Eclipse Public License v 2.0
 * which accompanies this distribution and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
 *
 * Contributors:
 * initial implementation              Alexandre Vasseur
 *******************************************************************************/
package org.aspectj.lang;

import org.aspectj.runtime.internal.AroundClosure;

/**
 * ProceedingJoinPoint exposes the proceed(..) method in order to support around advice in @AJ aspects
 *
 * @author Alexandre Vasseur
 */
public interface ProceedingJoinPoint extends JoinPoint {

    /**
     * The joinpoint needs to know about its closure so that proceed can delegate to closure.run().
     * This internal method should not be called directly, and won't be visible to the end-user when
     * packed in a jar (synthetic method).
     *
     * @param arc the around closure to associate with this joinpoint
     */
    void set$AroundClosure(AroundClosure arc);

    /**
     * The joinpoint needs to know about its closure so that proceed can delegate to closure.run().
     * This internal method should not be called directly, and won't be visible to the end-user when
     * packed in a jar (synthetic method). This should maintain a stack of closures as multiple around
     * advice with proceed are targeting a joinpoint and the stack will need to be unwound when
     * exiting nested advice. Passing a non null arc indicates a push, passing null indicates a pop.
     *
     * @param arc the around closure to associate with this joinpoint
     */
     default void stack$AroundClosure(AroundClosure arc) {
    	 throw new UnsupportedOperationException();
     }

    /**
     * Proceed with the next advice or target method invocation
     *
     * @return the result of proceeding
     * @throws Throwable if the invoked proceed throws anything
     */
	Object proceed() throws Throwable;

    /**
     * Proceed with the next advice or target method invocation.
     *
     * Unlike code style, proceed(..) in annotation style places different requirements on the
     * parameters passed to it.  The proceed(..) call takes, in this order:
     * 
     *  If 'this()' was used in the pointcut for binding, it must be passed first in proceed(..).
     * 
 If 'target()' was used in the pointcut for binding, it must be passed next in proceed(..) -
     * it will be the first argument to proceed(..) if this() was not used for binding.
     * 
 Finally come all the arguments expected at the join point, in the order they are supplied
     * at the join point. Effectively the advice signature is ignored - it doesn't matter
     * if a subset of arguments were bound or the ordering was changed in the advice signature,
     * the proceed(..) calls takes all of them in the right order for the join point.
     * 
     * Since proceed(..) in this case takes an Object array, AspectJ cannot do as much
     * compile time checking as it can for code style. If the rules above aren't obeyed
     * then it will unfortunately manifest as a runtime error.
     *
     * @param args the arguments to proceed with
     * @return the result of proceeding
     * @throws Throwable if the invoked proceed throws anything
     */
	Object proceed(Object[] args) throws Throwable;

}