Uses of Class
org.aspectj.weaver.ResolvedType
Packages that use ResolvedType
Package
Description
-
Uses of ResolvedType in org.aspectj.weaver
Subclasses of ResolvedType in org.aspectj.weaverModifier and TypeClassDescriptionclass
Represents a resolved array typeclass
A BoundedReferenceType is the result of a generics wildcard expression ?class
When we try to resolve a type in the world that we require to be present, and then fail to find it, we return an instance of this class.class
A reference type represents some 'real' type, not a primitive, not an array - but a real type, for example java.util.List.class
ReferenceType pointing to a type variable.Fields in org.aspectj.weaver declared as ResolvedTypeModifier and TypeFieldDescriptionprotected ResolvedType[]
ResolvedMemberImpl.annotationTypes
protected ResolvedType
ConcreteTypeMunger.aspectType
protected ResolvedType
Advice.concreteAspect
static ResolvedType[]
ResolvedType.EMPTY_ARRAY
static ResolvedType[]
ResolvedType.EMPTY_RESOLVED_TYPE_ARRAY
static ResolvedType[][]
static ResolvedType[]
ResolvedType.NONE
protected ResolvedType[][]
ResolvedMemberImpl.parameterAnnotationTypes
ResolvedType.temporaryAnnotationTypes
protected ResolvedType
AbstractAnnotationAJ.type
Methods in org.aspectj.weaver that return ResolvedTypeModifier and TypeMethodDescriptionResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
Look up the actual occurence of a particular type in the hierarchy for 'this' type.CrosscuttingMembersSet.findAspectDeclaringParents(DeclareParents p)
Lookup a type by its signature, always look in the real map before the expendable mapAnnotatedElement.getAnnotationTypes()
ArrayReferenceType.getAnnotationTypes()
GeneratedReferenceTypeDelegate.getAnnotationTypes()
JoinPointSignature.getAnnotationTypes()
ReferenceType.getAnnotationTypes()
ReferenceTypeDelegate.getAnnotationTypes()
ResolvedMember.getAnnotationTypes()
ResolvedMemberImpl.getAnnotationTypes()
ResolvedType.getAnnotationTypes()
ConcreteTypeMunger.getAspectType()
Advice.getConcreteAspect()
Checker.getConcreteAspect()
IntMap.getConcreteAspect()
abstract ResolvedType
ShadowMunger.getConcreteAspect()
World.getCoreType(UnresolvedType tx)
Special resolution for "core" types like OBJECT.ArrayReferenceType.getDeclaredInterfaces()
BoundedReferenceType.getDeclaredInterfaces()
GeneratedReferenceTypeDelegate.getDeclaredInterfaces()
MissingResolvedTypeWithKnownSignature.getDeclaredInterfaces()
ReferenceType.getDeclaredInterfaces()
Find out from the generic signature the true signature of any interfaces I implement.ReferenceTypeDelegate.getDeclaredInterfaces()
abstract ResolvedType[]
ResolvedType.getDeclaredInterfaces()
NewParentTypeMunger.getDeclaringType()
ResolvedType.getDeclaringType()
Returns a ResolvedType object representing the declaring type of this type, or null if this type does not represent a non-package-level-type.ShadowMunger.getDeclaringType()
BindingScope.getEnclosingType()
NewParentTypeMunger.getNewParent()
GeneratedReferenceTypeDelegate.getOuterClass()
ReferenceType.getOuterClass()
ReferenceTypeDelegate.getOuterClass()
ResolvedType.getOuterClass()
ResolvedType[][]
JoinPointSignature.getParameterAnnotationTypes()
ResolvedType[][]
ResolvedMember.getParameterAnnotationTypes()
ResolvedType[][]
ResolvedMemberImpl.getParameterAnnotationTypes()
ResolvedType.getRawType()
ResolvableTypeList.getResolved(int nameIndex)
ArrayReferenceType.getResolvedComponentType()
ResolvedType.getResolvedComponentType()
ResolvedType.getResolvedTypeParameters()
ArrayReferenceType.getSuperclass()
GeneratedReferenceTypeDelegate.getSuperclass()
MissingResolvedTypeWithKnownSignature.getSuperclass()
ReferenceType.getSuperclass()
ReferenceTypeDelegate.getSuperclass()
abstract ResolvedType
ResolvedType.getSuperclass()
ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
AbstractAnnotationAJ.getType()
AnnotationAJ.getType()
static ResolvedType
ResolvedType.makeArray(ResolvedType type, int dim)
Iterators.ResolvedTypeArrayIterator.next()
ResolvedType.parameterizedWith(UnresolvedType[] typeParameters)
World.TypeMap.put(String key, ResolvedType type)
Add a new type into the map, the key is the type signature.Remove a type from the mapresolve the type variable we are managing and then return this object.Returns a resolved version of this type according to a particular world.Convenience method for finding a type by name and resolving it in one step.World.resolve(ResolvedType ty)
Some TypeFactory operations create resolved types directly, but these won't be in the typeMap - this resolution process puts them there.World.resolve(UnresolvedType ty)
Resolve a type that we require to be present in the worldWorld.resolve(UnresolvedType[] types)
Convenience method for resolving an array of unresolved types in one hit.World.resolve(UnresolvedType ty, boolean allowMissing)
Resolve a type.World.resolve(UnresolvedType ty, ISourceLocation isl)
Attempt to resolve a type - the source location gives you some context in which resolution is taking place.World.resolveGenericTypeFor(UnresolvedType anUnresolvedType, boolean allowMissing)
Attempt to resolve a type that should be a generic type.Methods in org.aspectj.weaver that return types with arguments of type ResolvedTypeModifier and TypeMethodDescriptionstatic Iterator<ResolvedType>
Iterators.array(ResolvedType[] o, boolean genericsAware)
JoinPointSignature.getDeclaringTypes(World world)
Member.getDeclaringTypes(World world)
MemberImpl.getDeclaringTypes(World world)
ResolvedType.getDirectSupertypes()
Returns an iterator through ResolvedType objects representing all the direct supertypes of this type.World.getExclusionMap()
World.getExclusionMap()
World.getExpendable()
World.TypeMap.getExpendableMap()
World.getFixed()
ResolvedType.getHierarchy()
Return an iterator over the types in this types hierarchy - starting with this type first, then all superclasses up to Object and then all interfaces (starting with those 'nearest' this type).ResolvedType.getHierarchy(boolean wantGenerics, boolean wantDeclaredParents)
Return an iterator over the types in this types hierarchy - starting with this type first, then all superclasses up to Object and then all interfaces (starting with those 'nearest' this type).ResolvedType.getHierarchyWithoutIterator(boolean includeITDs, boolean allowMissing, boolean genericsAware)
Return a list of the types in the hierarchy of this type, starting with this type.World.TypeMap.getMainMap()
Checker.getThrownExceptions()
abstract Collection<ResolvedType>
ShadowMunger.getThrownExceptions()
Methods in org.aspectj.weaver with parameters of type ResolvedTypeModifier and TypeMethodDescriptionvoid
CrosscuttingMembersSet.addAdviceLikeDeclares(ResolvedType aspectType)
void
CrosscuttingMembersSet.addFixedCrosscuttingMembers(ResolvedType aspectType)
boolean
CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType)
boolean
CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType, boolean inWeavingPhase)
void
ReferenceType.addParent(ResolvedType newParent)
void
ResolvedType.addParent(ResolvedType newParent)
boolean
BoundedReferenceType.alwaysMatches(ResolvedType aCandidateType)
static Iterator<ResolvedType>
Iterators.array(ResolvedType[] o, boolean genericsAware)
boolean
TypeVariable.canBeBoundTo(ResolvedType candidate)
answer true if the given type satisfies all of the bound constraints of this type variable.boolean
BoundedReferenceType.canBeCoercedTo(ResolvedType aCandidateType)
boolean
ResolvedType.canBeSeenBy(ResolvedType from)
protected boolean
Shadow.checkCanThrow(ShadowMunger munger, ResolvedType resolvedTypeX)
boolean
ResolvedType.checkLegalOverride(ResolvedMember parent, ResolvedMember child, int transformerPosition, ResolvedType aspectType)
int
World.compareByPrecedence(ResolvedType aspect1, ResolvedType aspect2)
Same signature as org.aspectj.util.PartialOrder.PartialComparable.compareToint
World.compareByPrecedenceAndHierarchy(ResolvedType aspect1, ResolvedType aspect2)
compares by precedence with the additional rule that a super-aspect is sorted before its sub-aspectsprotected void
World.completeBinaryType(ResolvedType ret)
Called when a type is resolved - enables its type hierarchy to be finished off before we proceedIWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
Advice.concretize(ResolvedType fromType, World world, PerClause clause)
Checker.concretize(ResolvedType theAspect, World world, PerClause clause)
Concretize this Checker by concretizing the pointcutabstract ShadowMunger
ShadowMunger.concretize(ResolvedType fromType, World world, PerClause clause)
IWeavingSupport.createAccessForInlineMunger(ResolvedType inAspect)
IWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature, ResolvedType concreteAspect)
World.createAdviceMunger(AdviceKind kind, Pointcut p, Member signature, int extraParameterFlags, IHasSourceLocation loc, ResolvedType declaringAspect)
Create an advice shadow munger for the given advice kindCustomMungerFactory.createCustomShadowMungers(ResolvedType aspectType)
CustomMungerFactory.createCustomTypeMungers(ResolvedType aspectType)
static ReferenceType
TypeFactory.createParameterizedType(ResolvedType aBaseType, UnresolvedType[] someTypeParameters, World inAWorld)
Create a parameterized version of a generic type.void
World.TypeMap.demote(ResolvedType type)
ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
Look up the actual occurence of a particular type in the hierarchy for 'this' type.ReferenceType.findDerivativeType(ResolvedType[] typeParameters)
Look for a derivative type with the specified type parameters.World.getAspectScope(ResolvedType declaringType)
MethodDelegateTypeMunger.getDelegate(ResolvedType targetType)
NewConstructorTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
NewFieldTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
NewMethodTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
PrivilegedAccessMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
ResolvedTypeMunger.getMatchingSyntheticMember(Member member, ResolvedType aspectType)
World.getPrecedenceIfAny(ResolvedType aspect1, ResolvedType aspect2)
abstract Var
Shadow.getThisAspectInstanceVar(ResolvedType aspectType)
ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
WeaverStateInfo.getTypeMungers(ResolvedType onType)
boolean
World.hasUnsatisfiedDependency(ResolvedType aspectType)
Determine if the named aspect requires a particular type around in order to be useful.static ResolvedMember
AjcMemberMaker.interConstructor(ResolvedType targetType, ResolvedMember constructor, UnresolvedType aspectType)
static Member
AjcMemberMaker.interfaceConstructor(ResolvedType resolvedTypeX)
static ResolvedMember
AjcMemberMaker.interFieldInterfaceGetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType)
This instance method goes on the interface the field is declared onto as well as its top-most implementorsstatic ResolvedMember
AjcMemberMaker.interFieldInterfaceSetter(ResolvedMember field, ResolvedType onType, UnresolvedType aspectType)
This instance method goes on the interface the field is declared onto as well as its top-most implementorsboolean
WeaverStateInfo.isAspectAlreadyApplied(ResolvedType someAspect)
boolean
World.isAspectIncluded(ResolvedType aspectType)
boolean
ArrayReferenceType.isAssignableFrom(ResolvedType o)
boolean
ArrayReferenceType.isAssignableFrom(ResolvedType o, boolean allowMissing)
boolean
MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other)
boolean
MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other, boolean allowMissing)
boolean
ReferenceType.isAssignableFrom(ResolvedType other)
boolean
ReferenceType.isAssignableFrom(ResolvedType other, boolean allowMissing)
abstract boolean
ResolvedType.isAssignableFrom(ResolvedType other)
Determines if the variables of this type could be assigned values of another type without casting.abstract boolean
ResolvedType.isAssignableFrom(ResolvedType other, boolean allowMissing)
boolean
ArrayReferenceType.isCoerceableFrom(ResolvedType o)
boolean
MissingResolvedTypeWithKnownSignature.isCoerceableFrom(ResolvedType other)
boolean
ReferenceType.isCoerceableFrom(ResolvedType o)
abstract boolean
ResolvedType.isCoerceableFrom(ResolvedType other)
Determines if values of another type could possibly be cast to this type.boolean
ResolvedType.isConvertableFrom(ResolvedType other)
Determines if variables of this type could be assigned values of another with lots of help. java.lang.Object is convertable from all types.protected boolean
World.isExpendable(ResolvedType type)
Reference types we don't intend to weave may be ejected from the cache if we need the space.boolean
ResolvedType.isTopmostImplementor(ResolvedType interfaceType)
boolean
JoinPointSignature.isVisible(ResolvedType fromType)
boolean
ResolvedMember.isVisible(ResolvedType fromType)
boolean
ResolvedMemberImpl.isVisible(ResolvedType fromType)
static boolean
ResolvedType.isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType)
static ResolvedMember
AjcMemberMaker.itdAtDeclareParentsField(ResolvedType targetType, UnresolvedType itdType, UnresolvedType aspectType)
static ResolvedType
ResolvedType.makeArray(ResolvedType type, int dim)
IWeavingSupport.makeCflowAccessVar(ResolvedType formalType, Member cflowField, int arrayIndex)
static Advice
Advice.makeCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, int nFreeVars, List<ShadowMunger> innerCflowEntries, ResolvedType inAspect)
static Advice
Advice.makePerCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, ResolvedType inAspect, List<ShadowMunger> innerCflowEntries)
IWeavingSupport.makePerClauseAspect(ResolvedType aspect, PerClause.Kind kind)
Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as neededstatic Advice
Advice.makePerObjectEntry(World world, Pointcut entry, boolean isThis, ResolvedType inAspect)
static Advice
Advice.makePerTypeWithinEntry(World world, Pointcut p, ResolvedType inAspect)
static Advice
Advice.makeSoftener(World world, Pointcut entry, TypePattern exceptionType, ResolvedType inAspect, IHasSourceLocation loc)
boolean
ConcreteTypeMunger.matches(ResolvedType onType)
boolean
MethodDelegateTypeMunger.FieldHostTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
Match based on given type pattern, only classes can be matchedboolean
MethodDelegateTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
Match based on given type pattern, only classes can be matchedboolean
PerObjectInterfaceTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
boolean
PerTypeWithinTargetTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
boolean
ResolvedTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType)
boolean
ResolvedType.needsNoConversionFrom(ResolvedType o)
abstract ConcreteTypeMunger
ConcreteTypeMunger.parameterizedFor(ResolvedType targetType)
For an ITD made on a generic type that shares type variables with that target type, this method will tailor the ITD for a particular usage of the generic type - either in its raw or parameterized form.NewConstructorTypeMunger.parameterizedFor(ResolvedType target)
see ResolvedTypeMunger.parameterizedFor(ResolvedType)NewFieldTypeMunger.parameterizedFor(ResolvedType target)
see ResolvedTypeMunger.parameterizedFor(ResolvedType)NewMethodTypeMunger.parameterizedFor(ResolvedType target)
see ResolvedTypeMunger.parameterizedFor(ResolvedType)ResolvedTypeMunger.parameterizedFor(ResolvedType target)
Parameterizes a resolved type munger for a particular usage of its target type (this is used when the target type is generic and the ITD shares type variables with the target) see ConcreteTypeMunger.parameterizedForTemporaryTypeMunger.parameterizedFor(ResolvedType targetType)
JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, List<String> aliases)
ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, List<String> aliases)
ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized, List<String> aliases)
Return a resolvedmember in which all the type variables in the signature have been replaced with the given bindings.ResolvedPointcutDefinition.parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType, boolean isParameterized)
Called when asking a parameterized super-aspect for its pointcuts.Checker.parameterizeWith(ResolvedType declaringType, Map<String,UnresolvedType> typeVariableMap)
Parameterize the Checker by parameterizing the pointcutabstract ShadowMunger
ShadowMunger.parameterizeWith(ResolvedType declaringType, Map<String,UnresolvedType> typeVariableMap)
static ResolvedMember
AjcMemberMaker.perObjectField(UnresolvedType declaringType, ResolvedType aspectType)
static ResolvedMember
AjcMemberMaker.perTypeWithinField(UnresolvedType declaringType, ResolvedType aspectType)
static ResolvedMember
AjcMemberMaker.perTypeWithinWithinTypeField(UnresolvedType declaringType, ResolvedType aspectType)
World.TypeMap.put(String key, ResolvedType type)
Add a new type into the map, the key is the type signature.AjAttribute.AdviceAttribute.reify(Member signature, World world, ResolvedType concreteAspect)
AjAttribute.Aspect.reify(ResolvedType inAspect)
AjAttribute.TypeMunger.reify(World world, ResolvedType aspectType)
AjAttribute.Aspect.reifyFromAtAspectJ(ResolvedType inAspect)
World.resolve(ResolvedType ty)
Some TypeFactory operations create resolved types directly, but these won't be in the typeMap - this resolution process puts them there.void
JoinPointSignature.setAnnotationTypes(ResolvedType[] annotationtypes)
void
ResolvedMember.setAnnotationTypes(ResolvedType[] annotationtypes)
void
ResolvedMemberImpl.setAnnotationTypes(ResolvedType[] annotationTypes)
void
IntMap.setConcreteAspect(ResolvedType concreteAspect)
void
ShadowMunger.setDeclaringType(ResolvedType aType)
Invoked when the shadow munger of a resolved type are processed.void
GeneratedReferenceTypeDelegate.setSuperclass(ResolvedType superclass)
Constructors in org.aspectj.weaver with parameters of type ResolvedTypeModifierConstructorDescriptionAbstractAnnotationAJ(ResolvedType type)
ArrayReferenceType(String sig, String erasureSig, World world, ResolvedType componentType)
BindingScope(ResolvedType type, ISourceContext sourceContext, FormalBinding[] bindings)
ConcreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
CrosscuttingMembers(ResolvedType inAspect, boolean shouldConcretizeIfNeeded)
JoinPointSignature(ResolvedMember backing, ResolvedType aType)
NewParentTypeMunger(ResolvedType newParent, ResolvedType declaringType)
ReferenceType(ResolvedType theGenericType, ResolvedType[] theParameters, World aWorld)
Constructor used when creating a parameterized type.ResolvedTypeArrayIterator(ResolvedType[] array, List<String> alreadySeen, boolean wantGenerics)
StandardAnnotation(ResolvedType type, boolean isRuntimeVisible)
TemporaryTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType)
-
Uses of ResolvedType in org.aspectj.weaver.ast
Methods in org.aspectj.weaver.ast that return ResolvedTypeModifier and TypeMethodDescriptionCallExpr.getType()
abstract ResolvedType
Expr.getType()
FieldGet.getType()
Var.getType()
Methods in org.aspectj.weaver.ast with parameters of type ResolvedTypeModifier and TypeMethodDescriptionVar.getAccessorForValue(ResolvedType formalType, String formalName)
For an annotation this will return a variable that can access a specific field of the annotation (of the specified type) TODO what kind of behaviour happens for two annotation fields of the same type?static CallExpr
Expr.makeCallExpr(Member member, Expr[] exprs, ResolvedType returnType)
static Test
Test.makeHasAnnotation(Var v, ResolvedType annTy)
static Test
Test.makeInstanceof(Var v, ResolvedType ty)
Constructors in org.aspectj.weaver.ast with parameters of type ResolvedTypeModifierConstructorDescriptionCallExpr(Member m, Expr[] args, ResolvedType returnType)
FieldGet(Member field, ResolvedType resolvedType)
HasAnnotation(Var v, ResolvedType annType)
Var(ResolvedType variableType)
-
Uses of ResolvedType in org.aspectj.weaver.internal.tools
Methods in org.aspectj.weaver.internal.tools with parameters of type ResolvedTypeModifier and TypeMethodDescriptionprotected Pointcut
PointcutDesignatorHandlerBasedPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
StandardPointcutExpressionImpl.matchesStaticInitialization(ResolvedType aType)
-
Uses of ResolvedType in org.aspectj.weaver.patterns
Fields in org.aspectj.weaver.patterns declared as ResolvedTypeModifier and TypeFieldDescriptionprotected ResolvedType
PerClause.inAspect
protected ResolvedType
ExactTypePattern.resolvedType
Methods in org.aspectj.weaver.patterns that return ResolvedTypeModifier and TypeMethodDescriptionDeclareAnnotation.getAnnotationType()
ExposedState.getConcreteAspect()
Declare.getDeclaringType()
IScope.getEnclosingType()
ScopeWithTypeVariables.getEnclosingType()
SimpleScope.getEnclosingType()
ExactAnnotationFieldTypePattern.getResolvedAnnotationType()
ExactAnnotationTypePattern.getResolvedAnnotationType()
ExactTypePattern.getResolvedExactType(World world)
FastMatchInfo.getType()
Methods in org.aspectj.weaver.patterns that return types with arguments of type ResolvedTypeModifier and TypeMethodDescriptionDeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors)
Methods in org.aspectj.weaver.patterns with parameters of type ResolvedTypeModifier and TypeMethodDescriptionTypePatternQuestions.askQuestion(TypePattern pattern, ResolvedType type, TypePattern.MatchKind kind)
int
DeclarePrecedence.compare(ResolvedType aspect1, ResolvedType aspect2)
PerCflow.concretize(ResolvedType inAspect)
abstract PerClause
PerClause.concretize(ResolvedType inAspect)
PerFromSuper.concretize(ResolvedType inAspect)
PerObject.concretize(ResolvedType inAspect)
PerSingleton.concretize(ResolvedType inAspect)
PerTypeWithin.concretize(ResolvedType inAspect)
Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity)
Returns a new pointcut Only used by test casesPointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice)
Pointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
AndPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut
AnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut
ArgsAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
ArgsPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
CflowPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
ConcreteCflowPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
HandlerPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
IfPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
IfPointcut.IfFalsePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
IfPointcut.IfTruePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
KindedPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
NotPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
OrPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
PerClause.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected abstract Pointcut
Pointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
Resolves and removes ReferencePointcuts, replacing with basic onesReferencePointcut.concretize1(ResolvedType searchStart, ResolvedType declaringType, IntMap bindings)
protected Pointcut
ThisOrTargetAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
ThisOrTargetPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut
WithinAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
protected Pointcut
WithinCodeAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
WithincodePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
WithinPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings)
void
DeclareAnnotation.copyAnnotationTo(ResolvedType onType)
boolean
AndSignaturePattern.couldEverMatch(ResolvedType type)
boolean
DeclareAnnotation.couldEverMatch(ResolvedType type)
Return true if this declare annotation could ever match something in the specified type - only really able to make intelligent decision if a type was specified in the sig/type pattern signature.boolean
ISignaturePattern.couldEverMatch(ResolvedType type)
boolean
NotSignaturePattern.couldEverMatch(ResolvedType type)
boolean
OrSignaturePattern.couldEverMatch(ResolvedType type)
boolean
SignaturePattern.couldEverMatch(ResolvedType type)
boolean
SignaturePattern.declaringTypeMatchAllowingForCovariance(Member member, UnresolvedType shadowDeclaringType, World world, TypePattern returnTypePattern, ResolvedType sigReturn)
DeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors)
protected boolean
HasMemberTypePattern.hasMethod(ResolvedType type)
protected boolean
HasMemberTypePatternForPerThisMatching.hasMethod(ResolvedType type)
PerFromSuper.lookupConcretePerClause(ResolvedType lookupType)
boolean
DeclareParents.match(ResolvedType typeX)
AndAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
AnnotationPatternList.matches(ResolvedType[] someArgs)
abstract FuzzyBoolean
AnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
AnyAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
BindingAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
boolean
DeclareAnnotation.matches(ResolvedType type)
For declare atType.ExactAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
ExactAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
NotAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
OrAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
TypePattern.matches(ResolvedType type, TypePattern.MatchKind kind)
TypePatternList.matches(ResolvableTypeList types, TypePattern.MatchKind kind, ResolvedType[][] parameterAnnotations)
TypePatternList.matches(ResolvedType[] types, TypePattern.MatchKind kind)
TypePatternList.matches(ResolvedType[] types, TypePattern.MatchKind kind, ResolvedType[][] parameterAnnotations)
When called with TypePattern.STATIC this will always return either FuzzyBoolean.YES or FuzzyBoolean.NO.WildAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations)
protected boolean
AndTypePattern.matchesExactly(ResolvedType type)
protected boolean
AndTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
AnyTypePattern.matchesExactly(ResolvedType type)
protected boolean
AnyTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
AnyWithAnnotationTypePattern.matchesExactly(ResolvedType type)
protected boolean
AnyWithAnnotationTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
EllipsisTypePattern.matchesExactly(ResolvedType type)
protected boolean
EllipsisTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
ExactTypePattern.matchesExactly(ResolvedType matchType)
protected boolean
ExactTypePattern.matchesExactly(ResolvedType matchType, ResolvedType annotatedType)
protected boolean
HasMemberTypePattern.matchesExactly(ResolvedType type)
protected boolean
HasMemberTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
NotTypePattern.matchesExactly(ResolvedType type)
protected boolean
NotTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
NoTypePattern.matchesExactly(ResolvedType type)
protected boolean
NoTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
OrTypePattern.matchesExactly(ResolvedType type)
protected boolean
OrTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
TypeCategoryTypePattern.matchesExactly(ResolvedType type)
protected boolean
TypeCategoryTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected abstract boolean
TypePattern.matchesExactly(ResolvedType type)
protected abstract boolean
TypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
protected boolean
WildTypePattern.matchesExactly(ResolvedType type)
protected boolean
WildTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType)
AndTypePattern.matchesInstanceof(ResolvedType type)
AnyTypePattern.matchesInstanceof(ResolvedType type)
AnyWithAnnotationTypePattern.matchesInstanceof(ResolvedType type)
EllipsisTypePattern.matchesInstanceof(ResolvedType type)
ExactTypePattern.matchesInstanceof(ResolvedType matchType)
HasMemberTypePattern.matchesInstanceof(ResolvedType type)
NotTypePattern.matchesInstanceof(ResolvedType type)
NoTypePattern.matchesInstanceof(ResolvedType type)
OrTypePattern.matchesInstanceof(ResolvedType type)
TypeCategoryTypePattern.matchesInstanceof(ResolvedType type)
abstract FuzzyBoolean
TypePattern.matchesInstanceof(ResolvedType type)
WildTypePattern.matchesInstanceof(ResolvedType type)
boolean
AndTypePattern.matchesStatically(ResolvedType type)
boolean
NotTypePattern.matchesStatically(ResolvedType type)
boolean
OrTypePattern.matchesStatically(ResolvedType type)
boolean
TypePattern.matchesStatically(ResolvedType type)
protected boolean
AnyTypePattern.matchesSubtypes(ResolvedType type)
protected boolean
AnyWithAnnotationTypePattern.matchesSubtypes(ResolvedType type)
protected boolean
ExactTypePattern.matchesSubtypes(ResolvedType type)
protected boolean
NoTypePattern.matchesSubtypes(ResolvedType type)
protected boolean
TypePattern.matchesSubtypes(ResolvedType type)
protected boolean
TypePattern.matchesSubtypes(ResolvedType superType, ResolvedType annotatedType)
void
ArgsPointcut.postRead(ResolvedType enclosingType)
void
IfPointcut.IfFalsePointcut.postRead(ResolvedType enclosingType)
void
IfPointcut.IfTruePointcut.postRead(ResolvedType enclosingType)
void
KindedPointcut.postRead(ResolvedType enclosingType)
void
Pointcut.postRead(ResolvedType enclosingType)
void
ReferencePointcut.postRead(ResolvedType enclosingType)
void
SignaturePattern.postRead(ResolvedType enclosingType)
void
ThisOrTargetPointcut.postRead(ResolvedType enclosingType)
void
TypePattern.postRead(ResolvedType enclosingType)
void
TypePatternList.postRead(ResolvedType enclosingType)
void
WithincodePointcut.postRead(ResolvedType enclosingType)
void
WithinPointcut.postRead(ResolvedType enclosingType)
protected void
WildAnnotationTypePattern.resolveAnnotationValues(ResolvedType annotationType, IScope scope)
Resolve any annotation values specified, checking they are all well formed (valid names, valid values)void
DeclareAnnotation.setAspect(ResolvedType typeX)
void
ExposedState.setConcreteAspect(ResolvedType concreteAspect)
void
Declare.setDeclaringType(ResolvedType aType)
protected void
ExactAnnotationTypePattern.verifyIsAnnotationType(ResolvedType type, IScope scope)
Constructors in org.aspectj.weaver.patterns with parameters of type ResolvedTypeModifierConstructorDescriptionConcreteCflowPointcut(ResolvedType aspect, Member cflowField, List<ConcreteCflowPointcut.Slot> slots, boolean usesCounter)
FastMatchInfo(ResolvedType type, Shadow.Kind kind, World world)
PerThisOrTargetPointcutVisitor(boolean isTarget, ResolvedType fromAspectType)
Question(TypePattern pattern, ResolvedType type, TypePattern.MatchKind kind)
Slot(int formalIndex, ResolvedType formalType, int arrayIndex)
-
Uses of ResolvedType in org.aspectj.weaver.reflect
Methods in org.aspectj.weaver.reflect that return ResolvedTypeModifier and TypeMethodDescriptionAnnotationFinder.getAnnotations(Member onMember, boolean runtimeAnnotationsOnly)
ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()
ReflectionBasedResolvedMemberImpl.getAnnotationTypes()
ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()
ReflectionBasedReferenceTypeDelegate.getOuterClass()
ResolvedType[][]
AnnotationFinder.getParameterAnnotationTypes(Member onMember)
ResolvedType[][]
ReflectionBasedResolvedMemberImpl.getParameterAnnotationTypes()
ReflectionBasedReferenceTypeDelegate.getSuperclass()
static ResolvedType
static ResolvedType
ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(Class aClass, World aWorld)
ReflectionWorld.resolveUsingClass(Class<?> clazz)
Resolve a type using the specified class.Methods in org.aspectj.weaver.reflect with parameters of type ResolvedTypeModifier and TypeMethodDescriptionstatic ReflectionVar
ReflectionVar.createArgsAnnotationVar(ResolvedType type, int index, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createArgsVar(ResolvedType type, int index, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createAtAnnotationVar(ResolvedType annType, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createTargetAnnotationVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createTargetVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createThisAnnotationVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createThisVar(ResolvedType type, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createWithinAnnotationVar(ResolvedType annType, AnnotationFinder finder)
static ReflectionVar
ReflectionVar.createWithinCodeAnnotationVar(ResolvedType annType, AnnotationFinder finder)
AnnotationFinder.getAnnotation(ResolvedType annotationType, Object onObject)
AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, Class<?> aClass)
AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, Member aMember)
ReflectionShadow.getThisAspectInstanceVar(ResolvedType aspectType)
StandardShadow.getThisAspectInstanceVar(ResolvedType aspectType)
static Shadow
StandardShadow.makeStaticInitializationShadow(World inWorld, ResolvedType forType, MatchingContext withContext)
void
StandardShadowMatchImpl.setWithinType(ResolvedType aClass)
Constructors in org.aspectj.weaver.reflect with parameters of type ResolvedTypeModifierConstructorDescriptionReflectionFastMatchInfo(ResolvedType type, Shadow.Kind kind, MatchingContext context, World world)
ReflectionShadow(World world, Shadow.Kind kind, Member signature, Shadow enclosingShadow, ResolvedType enclosingType, ResolvedMember enclosingMember, MatchingContext withContext)
StandardShadow(World world, Shadow.Kind kind, Member signature, Shadow enclosingShadow, ResolvedType enclosingType, ResolvedMember enclosingMember, MatchingContext withContext)
-
Uses of ResolvedType in org.aspectj.weaver.tools
Methods in org.aspectj.weaver.tools with parameters of type ResolvedTypeModifier and TypeMethodDescriptionStandardPointcutExpression.matchesStaticInitialization(ResolvedType aType)
Determine whether or not this pointcut matches the static initialization of the given class.