WildTypePattern

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.aspectj.weaver.patterns
Class WildTypePattern

java.lang.Object
  org.aspectj.weaver.patterns.PatternNode
      org.aspectj.weaver.patterns.TypePattern
          org.aspectj.weaver.patterns.WildTypePattern

All Implemented Interfaces:: IHasPosition, IHasSourceLocation

public class WildTypePattern
extends TypePattern
extends TypePattern

The PatternParser always creates WildTypePatterns for type patterns in pointcut expressions (apart from *, which is sometimes directly turned into TypePattern.ANY). resolveBindings() tries to work out what we've really got and turn it into a type pattern that we can use for matching. This will normally be either an ExactTypePattern or a WildTypePattern. Here's how the process pans out for various generic and parameterized patterns: (see GenericsWildTypePatternResolvingTestCase) Foo where Foo exists and is generic Parser creates WildTypePattern namePatterns={Foo} resolveBindings resolves Foo to RT(Foo - raw) return ExactTypePattern(LFoo;) Foo where Foo exists and String meets the bounds Parser creates WildTypePattern namePatterns = {Foo}, typeParameters=WTP{String} resolveBindings resolves typeParameters to ExactTypePattern(String) resolves Foo to RT(Foo) returns ExactTypePattern(PFoo; - parameterized) Foo where Foo exists and takes one bound Parser creates WildTypePattern namePatterns = {Foo}, typeParameters=WTP{Str*} resolveBindings resolves typeParameters to WTP{Str*} resolves Foo to RT(Foo) returns WildTypePattern(name = Foo, typeParameters = WTP{Str*} isGeneric=false) Fo* Parser creates WildTypePattern namePatterns = {Fo*}, typeParameters=WTP{String} resolveBindings resolves typeParameters to ETP{String} returns WildTypePattern(name = Fo*, typeParameters = ETP{String} isGeneric=false) Foo Foo Foo Foo

Nested Class Summary

Nested classes/interfaces inherited from class org.aspectj.weaver.patterns.TypePattern
`TypePattern.MatchKind`

Field Summary
`static boolean`	`boundscheckingoff`

Fields inherited from class org.aspectj.weaver.patterns.TypePattern
`AND, annotationPattern, ANY, ANY_KEY, ANY_WITH_ANNO, BINDING, DYNAMIC, ELLIPSIS, ELLIPSIS_KEY, EXACT, HAS_MEMBER, includeSubtypes, isVarArgs, NO, NO_KEY, NOT, OR, STATIC, TYPE_CATEGORY, typeParameters, WILD`

Fields inherited from class org.aspectj.weaver.patterns.PatternNode
`end, sourceContext, start`

Constructor Summary
`WildTypePattern(java.util.List<NamePattern> names, boolean includeSubtypes, int dim)`
`WildTypePattern(java.util.List<NamePattern> names, boolean includeSubtypes, int dim, int endPos)`
`WildTypePattern(java.util.List<NamePattern> names, boolean includeSubtypes, int dim, int endPos, boolean isVarArg)`
`WildTypePattern(java.util.List<NamePattern> names, boolean includeSubtypes, int dim, int endPos, boolean isVarArg, TypePatternList typeParams)`
`WildTypePattern(java.util.List<NamePattern> names, boolean includeSubtypes, int dim, int endPos, boolean isVarArg, TypePatternList typeParams, TypePattern upperBound, TypePattern[] additionalInterfaceBounds, TypePattern lowerBound)`

Method Summary
`java.lang.Object`	`accept(PatternNodeVisitor visitor, java.lang.Object data)`
`protected boolean`	`couldEverMatchSameTypesAs(TypePattern other)`
`boolean`	`equals(java.lang.Object other)`
`NamePattern`	`extractName()`
`TypePattern[]`	`getAdditionalIntefaceBounds()`
`int`	`getDimensions()` Used in conjunction with checks on 'isStar()' to tell you if this pattern represents '' or '[]' which are different !
`TypePattern`	`getLowerBound()`
`NamePattern[]`	`getNamePatterns()`
`TypePattern`	`getUpperBound()`
`boolean`	`hasFailedResolution()`
`int`	`hashCode()`
`boolean`	`isArray()`
`boolean`	`isStar()`
`protected boolean`	`matchesExactly(ResolvedType type)`
`protected boolean`	`matchesExactly(ResolvedType type, ResolvedType annotatedType)`
`FuzzyBoolean`	`matchesInstanceof(ResolvedType type)`
`boolean`	`maybeExtractName(java.lang.String string)` Method maybeExtractName.
`java.lang.String`	`maybeGetCleanName()` If this type pattern has no '*' or '..' in it
`java.lang.String`	`maybeGetSimpleName()` If this type pattern has no '.' or '*' in it, then return a simple string otherwise, this will return null;
`TypePattern`	`parameterizeWith(java.util.Map<java.lang.String,UnresolvedType> typeVariableMap, World w)` return a version of this type pattern in which all type variable references have been replaced by their corresponding entry in the map.
`static TypePattern`	`read(VersionedDataInputStream s, ISourceContext context)`
`static TypePattern`	`readTypePattern150(VersionedDataInputStream s, ISourceContext context)`
`static TypePattern`	`readTypePatternOldStyle(VersionedDataInputStream s, ISourceContext context)`
`TypePattern`	`resolveBindings(IScope scope, Bindings bindings, boolean allowBinding, boolean requireExactType)` Need to determine if I'm really a pattern or a reference to a formal We may wish to further optimize the case of pattern vs.
`void`	`setIsVarArgs(boolean isVarArgs)`
`static char[][]`	`splitNames(java.lang.String s, boolean convertDollar)`
`java.lang.String`	`toString()`
`void`	`write(CompressingDataOutputStream s)`

Methods inherited from class org.aspectj.weaver.patterns.TypePattern
`getAnnotationPattern, getExactType, getTypeParameters, isBangVoid, isEllipsis, isIncludeSubtypes, isStarAnnotation, isVarArgs, isVoid, matches, matchesStatically, matchesSubtypes, matchesSubtypes, notExactType, postRead, remapAdviceFormals, resolve, resolveExactType, setAnnotationTypePattern, setTypeParameters`

Methods inherited from class org.aspectj.weaver.patterns.PatternNode
`copyLocationFrom, getEnd, getFileName, getSourceContext, getSourceLocation, getStart, readLocation, setLocation, traverse, writeLocation`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

boundscheckingoff

public static boolean boundscheckingoff

Constructor Detail