Package org.aspectj.weaver.patterns

Class Pointcut

java.lang.Object
org.aspectj.weaver.patterns.PatternNode
org.aspectj.weaver.patterns.Pointcut
All Implemented Interfaces:
IHasPosition, IHasSourceLocation
Direct Known Subclasses:
AndPointcut, CflowPointcut, ConcreteCflowPointcut, HandlerPointcut, IfPointcut, KindedPointcut, NameBindingPointcut, NotPointcut, OrPointcut, PerClause, PointcutDesignatorHandlerBasedPointcut, ReferencePointcut, WithincodePointcut, WithinPointcut
public abstract class Pointcut extends PatternNode
The lifecycle of Pointcuts is modeled by Pointcut.State. It has three things:

Creation -- SYMBOLIC -- then resolve(IScope) -- RESOLVED -- concretize(...) -- CONCRETE

Author:
Erik Hilsdale, Jim Hugunin A day in the life of a pointcut.... - AMC. ========================================== Pointcuts are created by the PatternParser, which is called by ajdt to parse a pointcut from the PseudoTokens AST node (which in turn are part of a PointcutDesignator AST node). Pointcuts are resolved by ajdt when an AdviceDeclaration or a PointcutDeclaration has its statements resolved. This happens as part of completeTypeBindings in the AjLookupEnvironment which is called after the diet parse phase of the compiler. Named pointcuts, and references to named pointcuts are instances of ReferencePointcut. At the end of the compilation process, the pointcuts are serialized (write method) into attributes in the class file. When the weaver loads the class files, it unpacks the attributes and deserializes the pointcuts (read). All aspects are added to the world, by calling addOrReplaceAspect on the crosscutting members set of the world. When aspects are added or replaced, the crosscutting members in the aspect are extracted as ShadowMungers (each holding a pointcut). The ShadowMungers are concretized, which concretizes the pointcuts. At this stage ReferencePointcuts are replaced by their declared content. During weaving, the weaver processes type by type. It first culls potentially matching ShadowMungers by calling the fastMatch method on their pointcuts. Only those that might match make it through to the next phase. At the next phase, all of the shadows within the type are created and passed to the pointcut for matching (match). When the actual munging happens, matched pointcuts are asked for their residue (findResidue) - the runtime test if any. Because of negation, findResidue may be called on pointcuts that could never match the shadow.

  • Field Details

  • Constructor Details

    • Pointcut

      public Pointcut()
      Constructor for Pattern.

  • Method Details

    • fastMatch

      public abstract FuzzyBoolean fastMatch​(FastMatchInfo info)
      Could I match any shadows in the code defined within this type?

    • couldMatchKinds

      public abstract int couldMatchKinds()
      The set of ShadowKinds that this Pointcut could possibly match - an int whose bits are set according to the Kinds specified in Shadow.java

    • getTypeVariablesInScope

      public String[] getTypeVariablesInScope()

    • setTypeVariablesInScope

      public void setTypeVariablesInScope​(String[] typeVars)

    • match

      public final FuzzyBoolean match​(Shadow shadow)
      Do I really match this shadow? XXX implementors need to handle state

    • matchInternal

      protected abstract FuzzyBoolean matchInternal​(Shadow shadow)

    • getPointcutKind

      public byte getPointcutKind()

    • resolveBindings

      protected abstract void resolveBindings​(IScope scope, Bindings bindings)

    • resolve

      public final Pointcut resolve​(IScope scope)
      Returns this pointcut mutated

    • concretize

      public final Pointcut concretize​(ResolvedType inAspect, ResolvedType declaringType, int arity)
      Returns a new pointcut Only used by test cases

    • concretize

      public final Pointcut concretize​(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice)

    • isDeclare

      public boolean isDeclare​(ShadowMunger munger)

    • concretize

      public final Pointcut concretize​(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)

    • shouldCopyLocationForConcretize

      protected boolean shouldCopyLocationForConcretize()

    • concretize1

      protected abstract Pointcut concretize1​(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
      Resolves and removes ReferencePointcuts, replacing with basic ones
      Parameters:
      inAspect - the aspect to resolve relative to
      bindings - a Map from formal index in the current lexical context → formal index in the concrete advice that will run This must always return a new Pointcut object (even if the concretized Pointcut is identical to the resolved one). That behavior is assumed in many places. XXX fix implementors to handle state

    • findResidue

      public final Test findResidue​(Shadow shadow, ExposedState state)
      This can be called from NotPointcut even for Pointcuts that don't match the shadow

    • findResidueInternal

      protected abstract Test findResidueInternal​(Shadow shadow, ExposedState state)

    • postRead

      public void postRead​(ResolvedType enclosingType)

    • read

      public static Pointcut read​(VersionedDataInputStream s, ISourceContext context) throws IOException
      Throws:
      IOException

    • check

      public void check​(ISourceContext ctx, World world)

    • fromString

      public static Pointcut fromString​(String str)

    • makeMatchesNothing

      public static Pointcut makeMatchesNothing​(Pointcut.State state)

    • assertState

      public void assertState​(Pointcut.State state)

    • parameterizeWith

      public abstract Pointcut parameterizeWith​(Map<String,​UnresolvedType> typeVariableMap, World w)