All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Search JAR files by class name

Source code of the class StandardPointcutExpression.java part of aspectjweaver version 1.8.9

Go to download Show more of this group Show artifacts with the name aspectjweaver
        /* *******************************************************************
 * Copyright (c) 2004 IBM Corporation.
 * All rights reserved. 
 * This program and the accompanying materials are made available 
 * under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution and is available at 
 * http://www.eclipse.org/legal/epl-v10.html 
 *  
 * ******************************************************************/

package org.aspectj.weaver.tools;

import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedType;

/**
 * Represents an AspectJ pointcut expression and provides convenience methods to determine whether or not the pointcut matches join
 * points specified in terms of the java.lang.reflect interfaces.
 */
public interface StandardPointcutExpression {

	/**
	 * Set the matching context to be used for subsequent calls to match.
	 * 
	 * @see MatchingContext
	 */
	void setMatchingContext(MatchingContext aMatchContext);

	/**
	 * Determine whether or not this pointcut could ever match a join point in the given class.
	 * 
	 * @param aClass the candidate class
	 * @return true iff this pointcut may match a join point within(aClass), and false otherwise
	 */
	boolean couldMatchJoinPointsInType(Class aClass);

	/**
	 * Returns true iff this pointcut contains any expression that might necessitate a dynamic test at some join point (e.g. args)
	 */
	boolean mayNeedDynamicTest();

	/**
	 * Determine whether or not this pointcut matches the execution of a given method.
	 * 
	 * @param aMethod the method being executed
	 * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing the
	 *         execution of the method.
	 */
	ShadowMatch matchesMethodExecution(ResolvedMember aMethod);

	// /**
	// * Determine whether or not this pointcut matches the execution of a given constructor.
	// *
	// * @param aConstructor the constructor being executed
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing the
	// * execution of the constructor.
	// */
	// ShadowMatch matchesConstructorExecution(Constructor aConstructor);
	//
	/**
	 * Determine whether or not this pointcut matches the static initialization of the given class.
	 * 
	 * @param aClass the class being statically initialized
	 * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matchs join points representing the static
	 *         initialization of the given type
	 */
	ShadowMatch matchesStaticInitialization(ResolvedType aType);

	//
	// /**
	// * Determine whether or not this pointcut matches the static initialization of the given class.
	// *
	// * @param aClass the class being statically initialized
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matchs join points representing the
	// static
	// * initialization of the given type
	// */
	// ShadowMatch matchesStaticInitialization(ResolvedType type);
	//
	// /**
	// * Determine whether or not this pointcut matches the execution of a given piece of advice.
	// *
	// * @param anAdviceMethod a method representing the advice being executed
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing the
	// * execution of the advice.
	// */
	// ShadowMatch matchesAdviceExecution(Method anAdviceMethod);
	//
	// /**
	// * Determine whether or not this pointcut matches the initialization of an object initiated by a call to the given
	// constructor.
	// *
	// * @param aConstructor the constructor initiating the initialization
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing
	// * initialization via the given constructor.
	// */
	// ShadowMatch matchesInitialization(Constructor aConstructor);
	//
	// /**
	// * Determine whether or not this pointcut matches the pre-initialization of an object initiated by a call to the given
	// * constructor.
	// *
	// * @param aConstructor the constructor initiating the initialization
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing
	// * pre-initialization via the given constructor.
	// */
	// ShadowMatch matchesPreInitialization(Constructor aConstructor);
	//
	/**
	 * Determine whether or not this pointcut matches a method call to the given method, made during the execution of the given
	 * method or constructor.
	 * 
	 * @param aMethod the method being called
	 * @param withinCode the Method or Constructor from within which the call is made
	 * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing a call to
	 *         this method during the execution of the given member.
	 */
	ShadowMatch matchesMethodCall(ResolvedMember aMethod, ResolvedMember withinCode);

	//
	// /**
	// * Determine whether or not this pointcut matches a method call to the given method, made outside of the scope of any method
	// or
	// * constructor, but within the callerType (for example, during static initialization of the type).
	// *
	// * @param aMethod the method being called
	// * @param callerType the declared type of the caller
	// * @param receiverType the declared type of the recipient of the call
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing a call
	// to
	// * this method during the execution of the given member.
	// */
	// ShadowMatch matchesMethodCall(Method aMethod, Class callerType);
	//
	// /**
	// * Determine whether or not this pointcut matches a method call to the given constructor, made during the execution of the
	// given
	// * method or constructor.
	// *
	// * @param aConstructor the constructor being called
	// * @param withinCode the Method or Constructor from within which the call is made
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing a call
	// to
	// * this constructor during the execution of the given member.
	// */
	// ShadowMatch matchesConstructorCall(Constructor aConstructor, Member withinCode);
	//
	// /**
	// * Determine whether or not this pointcut matches a method call to the given constructor, made outside of the scope of any
	// * method or constructor, but within the callerType.
	// *
	// * @param aConstructor the cosstructor being called
	// * @param callerType the declared type of the caller
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing a call
	// to
	// * this constructor during the execution of the given member.
	// */
	// ShadowMatch matchesConstructorCall(Constructor aConstructor, Class callerType);
	//
	// /**
	// * Determine whether or not this pointcut matches the execution of a given exception handler within the given method or
	// * constructor
	// *
	// * @param exceptionType the static type of the exception being handled
	// * @param withinCode the method or constructor in which the catch block is declared
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing the
	// * handling of the given exception
	// */
	// ShadowMatch matchesHandler(Class exceptionType, Member withinCode);
	//
	// /**
	// * Determine whether or not this pointcut matches the execution of a given exception handler outside of the scope of any
	// method
	// * or constructor, but within the handling type.
	// *
	// * @param exceptionType the static type of the exception being handled
	// * @param handlingType the type in which the handler block is executing
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches join points representing the
	// * handling of the given exception
	// */
	// ShadowMatch matchesHandler(Class exceptionType, Class handlingType);
	//
	// /**
	// * Determine whether or not this pointcut matches a set of the given field from within the given method or constructor.
	// *
	// * @param aField the field being updated
	// * @param withinCode the Method or Constructor owning the call site
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches field set join points for the
	// given
	// * field and call site.
	// */
	// ShadowMatch matchesFieldSet(Field aField, Member withinCode);
	//
	// /**
	// * Determine whether or not this pointcut matches a set of the given field outside of the scope of any method or constructor,
	// * but within the given type (for example, during static initialization).
	// *
	// * @param aField the field being updated
	// * @param withinType the type owning the call site
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches field set join points for the
	// given
	// * field and call site.
	// */
	// ShadowMatch matchesFieldSet(Field aField, Class withinType);
	//
	// /**
	// * Determine whether or not this pointcut matches a get of the given field from within the given method or constructor.
	// *
	// * @param aField the field being updated
	// * @param withinCode the Method or Constructor owning the call site
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches field get join points for the
	// given
	// * field and call site.
	// */
	// ShadowMatch matchesFieldGet(Field aField, Member withinCode);
	//
	// /**
	// * Determine whether or not this pointcut matches a get of the given field outside of the scope of any method or constructor,
	// * but within the given type (for example, during static initialization).
	// *
	// * @param aField the field being accessed
	// * @param withinType the type owning the call site
	// * @return a ShadowMatch indicating whether the pointcut always, sometimes, or never matches field get join points for the
	// given
	// * field and call site.
	// */
	// ShadowMatch matchesFieldGet(Field aField, Class withinType);

	/**
	 * Return a string representation of this pointcut expression.
	 */
	String getPointcutExpression();
}




© 2018 Weber Informatics LLC