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 TypeClassDescriptionclassRepresents a resolved array typeclassA BoundedReferenceType is the result of a generics wildcard expression ?classWhen 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.classA reference type represents some 'real' type, not a primitive, not an array - but a real type, for example java.util.List.classReferenceType pointing to a type variable.Fields in org.aspectj.weaver declared as ResolvedTypeModifier and TypeFieldDescriptionprotected ResolvedType[]ResolvedMemberImpl.annotationTypesprotected ResolvedTypeConcreteTypeMunger.aspectTypeprotected ResolvedTypeAdvice.concreteAspectstatic final ResolvedType[]ResolvedType.EMPTY_ARRAYstatic final ResolvedType[]ResolvedType.EMPTY_RESOLVED_TYPE_ARRAYstatic final ResolvedType[][]static final ResolvedType[]ResolvedType.NONEprotected ResolvedType[][]ResolvedMemberImpl.parameterAnnotationTypesResolvedType.temporaryAnnotationTypesprotected final ResolvedTypeAbstractAnnotationAJ.typeMethods 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 ResolvedTypeShadowMunger.getConcreteAspect()World.getCoreType(UnresolvedType tx) Special resolution for "core" types like OBJECT.final ResolvedType[]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()final ResolvedTypeArrayReferenceType.getSuperclass()GeneratedReferenceTypeDelegate.getSuperclass()MissingResolvedTypeWithKnownSignature.getSuperclass()ReferenceType.getSuperclass()ReferenceTypeDelegate.getSuperclass()abstract ResolvedTypeResolvedType.getSuperclass()ResolvedType.getTopmostImplementor(ResolvedType interfaceType) final ResolvedTypeAbstractAnnotationAJ.getType()AnnotationAJ.getType()static ResolvedTypeResolvedType.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) final Iterator<ResolvedType>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 TypeMethodDescriptionvoidCrosscuttingMembersSet.addAdviceLikeDeclares(ResolvedType aspectType) voidCrosscuttingMembersSet.addFixedCrosscuttingMembers(ResolvedType aspectType) booleanCrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType) booleanCrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType, boolean inWeavingPhase) voidReferenceType.addParent(ResolvedType newParent) voidResolvedType.addParent(ResolvedType newParent) booleanBoundedReferenceType.alwaysMatches(ResolvedType aCandidateType) static Iterator<ResolvedType>Iterators.array(ResolvedType[] o, boolean genericsAware) booleanTypeVariable.canBeBoundTo(ResolvedType candidate) answer true if the given type satisfies all of the bound constraints of this type variable.booleanBoundedReferenceType.canBeCoercedTo(ResolvedType aCandidateType) booleanResolvedType.canBeSeenBy(ResolvedType from) protected booleanShadow.checkCanThrow(ShadowMunger munger, ResolvedType resolvedTypeX) booleanResolvedType.checkLegalOverride(ResolvedMember parent, ResolvedMember child, int transformerPosition, ResolvedType aspectType) intWorld.compareByPrecedence(ResolvedType aspect1, ResolvedType aspect2) Same signature as org.aspectj.util.PartialOrder.PartialComparable.compareTointWorld.compareByPrecedenceAndHierarchy(ResolvedType aspect1, ResolvedType aspect2) compares by precedence with the additional rule that a super-aspect is sorted before its sub-aspectsprotected voidWorld.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 ShadowMungerShadowMunger.concretize(ResolvedType fromType, World world, PerClause clause) IWeavingSupport.createAccessForInlineMunger(ResolvedType inAspect) IWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature, ResolvedType concreteAspect) final AdviceWorld.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 ReferenceTypeTypeFactory.createParameterizedType(ResolvedType aBaseType, UnresolvedType[] someTypeParameters, World inAWorld) Create a parameterized version of a generic type.voidWorld.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 VarShadow.getThisAspectInstanceVar(ResolvedType aspectType) ResolvedType.getTopmostImplementor(ResolvedType interfaceType) WeaverStateInfo.getTypeMungers(ResolvedType onType) booleanWorld.hasUnsatisfiedDependency(ResolvedType aspectType) Determine if the named aspect requires a particular type around in order to be useful.static ResolvedMemberAjcMemberMaker.interConstructor(ResolvedType targetType, ResolvedMember constructor, UnresolvedType aspectType) static MemberAjcMemberMaker.interfaceConstructor(ResolvedType resolvedTypeX) static ResolvedMemberAjcMemberMaker.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 ResolvedMemberAjcMemberMaker.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 implementorsbooleanWeaverStateInfo.isAspectAlreadyApplied(ResolvedType someAspect) booleanWorld.isAspectIncluded(ResolvedType aspectType) final booleanArrayReferenceType.isAssignableFrom(ResolvedType o) booleanArrayReferenceType.isAssignableFrom(ResolvedType o, boolean allowMissing) booleanMissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other) booleanMissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other, boolean allowMissing) booleanReferenceType.isAssignableFrom(ResolvedType other) booleanReferenceType.isAssignableFrom(ResolvedType other, boolean allowMissing) abstract booleanResolvedType.isAssignableFrom(ResolvedType other) Determines if the variables of this type could be assigned values of another type without casting.abstract booleanResolvedType.isAssignableFrom(ResolvedType other, boolean allowMissing) final booleanArrayReferenceType.isCoerceableFrom(ResolvedType o) booleanMissingResolvedTypeWithKnownSignature.isCoerceableFrom(ResolvedType other) booleanReferenceType.isCoerceableFrom(ResolvedType o) abstract booleanResolvedType.isCoerceableFrom(ResolvedType other) Determines if values of another type could possibly be cast to this type.final booleanResolvedType.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 booleanWorld.isExpendable(ResolvedType type) Reference types we don't intend to weave may be ejected from the cache if we need the space.booleanResolvedType.isTopmostImplementor(ResolvedType interfaceType) booleanJoinPointSignature.isVisible(ResolvedType fromType) booleanResolvedMember.isVisible(ResolvedType fromType) booleanResolvedMemberImpl.isVisible(ResolvedType fromType) static booleanResolvedType.isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType) static ResolvedMemberAjcMemberMaker.itdAtDeclareParentsField(ResolvedType targetType, UnresolvedType itdType, UnresolvedType aspectType) static ResolvedTypeResolvedType.makeArray(ResolvedType type, int dim) IWeavingSupport.makeCflowAccessVar(ResolvedType formalType, Member cflowField, int arrayIndex) static AdviceAdvice.makeCflowEntry(World world, Pointcut entry, boolean isBelow, Member stackField, int nFreeVars, List<ShadowMunger> innerCflowEntries, ResolvedType inAspect) static AdviceAdvice.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 AdviceAdvice.makePerObjectEntry(World world, Pointcut entry, boolean isThis, ResolvedType inAspect) static AdviceAdvice.makePerTypeWithinEntry(World world, Pointcut p, ResolvedType inAspect) static AdviceAdvice.makeSoftener(World world, Pointcut entry, TypePattern exceptionType, ResolvedType inAspect, IHasSourceLocation loc) booleanConcreteTypeMunger.matches(ResolvedType onType) booleanMethodDelegateTypeMunger.FieldHostTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType) Match based on given type pattern, only classes can be matchedbooleanMethodDelegateTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType) Match based on given type pattern, only classes can be matchedbooleanPerObjectInterfaceTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType) booleanPerTypeWithinTargetTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType) booleanResolvedTypeMunger.matches(ResolvedType matchType, ResolvedType aspectType) booleanResolvedType.needsNoConversionFrom(ResolvedType o) abstract ConcreteTypeMungerConcreteTypeMunger.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 ShadowMungerShadowMunger.parameterizeWith(ResolvedType declaringType, Map<String, UnresolvedType> typeVariableMap) static ResolvedMemberAjcMemberMaker.perObjectField(UnresolvedType declaringType, ResolvedType aspectType) static ResolvedMemberAjcMemberMaker.perTypeWithinField(UnresolvedType declaringType, ResolvedType aspectType) static ResolvedMemberAjcMemberMaker.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.voidJoinPointSignature.setAnnotationTypes(ResolvedType[] annotationtypes) voidResolvedMember.setAnnotationTypes(ResolvedType[] annotationtypes) voidResolvedMemberImpl.setAnnotationTypes(ResolvedType[] annotationTypes) voidIntMap.setConcreteAspect(ResolvedType concreteAspect) voidShadowMunger.setDeclaringType(ResolvedType aType) Invoked when the shadow munger of a resolved type are processed.voidGeneratedReferenceTypeDelegate.setSuperclass(ResolvedType superclass) Constructors in org.aspectj.weaver with parameters of type ResolvedTypeModifierConstructorDescriptionArrayReferenceType(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 ResolvedTypeExpr.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 CallExprExpr.makeCallExpr(Member member, Expr[] exprs, ResolvedType returnType) static TestTest.makeHasAnnotation(Var v, ResolvedType annTy) static TestTest.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.bcel
Fields in org.aspectj.weaver.bcel declared as ResolvedTypeMethods in org.aspectj.weaver.bcel that return ResolvedTypeModifier and TypeMethodDescriptionBcelWeaver.addLibraryAspect(String aspectName) Add the given aspect to the weaver.static ResolvedTypeBcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(GenericSignature.ClassTypeSignature aClassTypeSignature, GenericSignature.FormalTypeParameter[] typeParams, World world) static ResolvedTypeBcelGenericSignatureToTypeXConverter.fieldTypeSignature2TypeX(GenericSignature.FieldTypeSignature aFieldTypeSignature, GenericSignature.FormalTypeParameter[] typeParams, World world) protected ResolvedType[]BcelShadow.getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) BcelObjectType.getAnnotationTypes()LazyMethodGen.getAnnotationTypes()BcelObjectType.getDeclaredInterfaces()Retrieves the declared interfaces - this allows for the generic signature on a type.BcelShadow.getEnclosingType()BcelObjectType.getOuterClass()BcelObjectType.getSuperclass()Must take into account generic signatureLazyClassGen.getSuperClass()LazyClassGen.getType()static ResolvedTypeBcelGenericSignatureToTypeXConverter.typeSignature2TypeX(GenericSignature.TypeSignature aTypeSig, GenericSignature.FormalTypeParameter[] typeParams, World world) Methods in org.aspectj.weaver.bcel with parameters of type ResolvedTypeModifier and TypeMethodDescriptionvoidLazyClassGen.addInterface(ResolvedType newInterface, ISourceLocation sourceLocation) static voidUtility.appendConversion(InstructionList il, InstructionFactory fact, ResolvedType fromType, ResolvedType toType) voidAnnotationAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType) voidAspectInstanceVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType) voidBcelCflowAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType) voidBcelVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType) voidTypeAnnotationAccessVar.appendLoadAndConvert(InstructionList il, InstructionFactory fact, ResolvedType toType) booleanBcelTypeMunger.attemptToModifySuperCalls(org.aspectj.weaver.bcel.BcelClassWeaver weaver, LazyClassGen newParentTarget, ResolvedType newParent) The main part of implementing declare parents extends.BcelWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType) BcelWeavingSupport.createAccessForInlineMunger(ResolvedType aspect) BcelWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute, Pointcut pointcut, Member signature, ResolvedType concreteAspect) BcelCflowAccessVar.createLoadInstructions(ResolvedType toType, InstructionFactory fact) TypeAnnotationAccessVar.createLoadInstructions(ResolvedType toType, InstructionFactory fact) voidBcelWorld.demote(ResolvedType type) Force demote a type.AnnotationAccessVar.getAccessorForValue(ResolvedType valueType, String formalName) Return an object that can access a particular value of this annotation.LazyClassGen.getAnnotationCachingField(BcelShadow shadow, ResolvedType toType, boolean isWithin) Create a field in the type containing the shadow where the annotation retrieved during binding can be stored - for later fast access.protected ResolvedType[]BcelShadow.getAnnotations(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) BcelWorld.getAspectScope(ResolvedType declaringType) static BcelObjectTypeBcelWorld.getBcelObjectType(ResolvedType concreteAspect) Retrieve a bcel delegate for an aspect - this will return NULL if the delegate is an EclipseSourceType and not a BcelObjectType - this happens quite often when incrementally compiling.protected ResolvedMemberBcelShadow.getRelevantMember(ResolvedMember foundMember, Member relevantMember, ResolvedType relevantType) BcelShadow.getThisAspectInstanceVar(ResolvedType aspectType) static booleanLazyClassGen.hasSerialVersionUIDField(ResolvedType type) booleanBcelWorld.hasUnsatisfiedDependency(ResolvedType aspectType) booleanBcelWorld.isAspectIncluded(ResolvedType aspectType) BcelWeavingSupport.makeCflowAccessVar(ResolvedType formalType, Member cflowField, int arrayIndex) BcelWeavingSupport.makePerClauseAspect(ResolvedType aspect, PerClause.Kind kind) Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as neededbooleanBcelAccessForInlineMunger.matches(ResolvedType onType) Match only the aspect for which we actbooleanBcelCflowCounterFieldAdder.matches(ResolvedType onType) booleanBcelCflowStackFieldAdder.matches(ResolvedType onType) booleanBcelPerClauseAspectAdder.matches(ResolvedType onType) BcelTypeMunger.parameterizedFor(ResolvedType target) static BcelVar[]Utility.pushAndReturnArrayOfVars(ResolvedType[] proceedParamTypes, InstructionList il, InstructionFactory fact, LazyMethodGen enclosingMethod) static List<AjAttribute>AtAjAttributes.readAj5FieldAttributes(Field field, org.aspectj.weaver.bcel.BcelField bField, ResolvedType type, ISourceContext context, IMessageHandler msgHandler) Extract field level annotations and turn them into AjAttributes.static List<AjAttribute>AtAjAttributes.readAj5MethodAttributes(Method method, org.aspectj.weaver.bcel.BcelMethod bMethod, ResolvedType type, ResolvedPointcutDefinition preResolvedPointcut, ISourceContext context, IMessageHandler msgHandler) Extract method level annotations and turn them into AjAttributes.voidLazyMethodGen.removeAnnotation(ResolvedType annotationType) voidLazyClassGen.setSuperClass(ResolvedType newSuperclass) protected voidBcelWorld.weaveInterTypeDeclarations(ResolvedType onType) voidBcelWeaver.weaveNormalTypeMungers(ResolvedType onType) voidBcelWeaver.weaveParentTypeMungers(ResolvedType onType) Weaves new parents and annotations onto a type ("declare parents" and "declare @type") Algorithm: 1.Constructors in org.aspectj.weaver.bcel with parameters of type ResolvedTypeModifierConstructorDescriptionAnnotationAccessVar(BcelShadow shadow, Shadow.Kind kind, ResolvedType annotationType, UnresolvedType theTargetIsStoredHere, Member sig, boolean isWithin) BcelAccessForInlineMunger(ResolvedType aspectType) BcelAnnotation(AnnotationGen theBcelAnnotation, ResolvedType resolvedAnnotationType) BcelCflowAccessVar(ResolvedType type, Member stackField, int index) BcelFieldRef(ResolvedType type, String className, String fieldName) BcelPerClauseAspectAdder(ResolvedType aspect, PerClause.Kind kind) BcelTypeMunger(ResolvedTypeMunger munger, ResolvedType aspectType) BcelVar(ResolvedType type, int slot) TypeAnnotationAccessVar(ResolvedType type, BcelVar theAnnotatedTargetIsStoredHere) -
Uses of ResolvedType in org.aspectj.weaver.internal.tools
Methods in org.aspectj.weaver.internal.tools with parameters of type ResolvedTypeModifier and TypeMethodDescriptionprotected PointcutPointcutDesignatorHandlerBasedPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) StandardPointcutExpressionImpl.matchesStaticInitialization(ResolvedType aType) -
Uses of ResolvedType in org.aspectj.weaver.ltw
Methods in org.aspectj.weaver.ltw that return ResolvedTypeModifier and TypeMethodDescriptionprotected ResolvedTypeLTWWorld.completeNonLocalType(ResolvedType ret) Methods in org.aspectj.weaver.ltw with parameters of type ResolvedTypeModifier and TypeMethodDescriptionprotected voidLTWWorld.completeBinaryType(ResolvedType ret) protected ResolvedTypeLTWWorld.completeNonLocalType(ResolvedType ret) -
Uses of ResolvedType in org.aspectj.weaver.model
Methods in org.aspectj.weaver.model with parameters of type ResolvedTypeModifier and TypeMethodDescriptionstatic voidAsmRelationshipProvider.addRelationship(AsmManager model, ResolvedType onType, ResolvedTypeMunger typeTransformer, ResolvedType originatingAspect) Add a relationship for a type transformation (declare parents, intertype method declaration, declare annotation on type). -
Uses of ResolvedType in org.aspectj.weaver.patterns
Fields in org.aspectj.weaver.patterns declared as ResolvedTypeModifier and TypeFieldDescriptionprotected ResolvedTypePerClause.inAspectprotected ResolvedTypeExactTypePattern.resolvedTypeMethods 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) intDeclarePrecedence.compare(ResolvedType aspect1, ResolvedType aspect2) PerCflow.concretize(ResolvedType inAspect) abstract PerClausePerClause.concretize(ResolvedType inAspect) PerFromSuper.concretize(ResolvedType inAspect) PerObject.concretize(ResolvedType inAspect) PerSingleton.concretize(ResolvedType inAspect) PerTypeWithin.concretize(ResolvedType inAspect) final PointcutPointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity) Returns a new pointcut Only used by test casesfinal PointcutPointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, int arity, ShadowMunger advice) final PointcutPointcut.concretize(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) AndPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) protected PointcutAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) protected PointcutArgsAnnotationPointcut.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) final PointcutPerClause.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) protected abstract PointcutPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) Resolves and removes ReferencePointcuts, replacing with basic onesReferencePointcut.concretize1(ResolvedType searchStart, ResolvedType declaringType, IntMap bindings) protected PointcutThisOrTargetAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) ThisOrTargetPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) protected PointcutWithinAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) protected PointcutWithinCodeAnnotationPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) WithincodePointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) WithinPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) voidDeclareAnnotation.copyAnnotationTo(ResolvedType onType) booleanAndSignaturePattern.couldEverMatch(ResolvedType type) booleanDeclareAnnotation.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.booleanISignaturePattern.couldEverMatch(ResolvedType type) booleanNotSignaturePattern.couldEverMatch(ResolvedType type) booleanOrSignaturePattern.couldEverMatch(ResolvedType type) booleanSignaturePattern.couldEverMatch(ResolvedType type) booleanSignaturePattern.declaringTypeMatchAllowingForCovariance(Member member, UnresolvedType shadowDeclaringType, World world, TypePattern returnTypePattern, ResolvedType sigReturn) DeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors) protected booleanHasMemberTypePattern.hasMethod(ResolvedType type) protected booleanHasMemberTypePatternForPerThisMatching.hasMethod(ResolvedType type) PerFromSuper.lookupConcretePerClause(ResolvedType lookupType) booleanDeclareParents.match(ResolvedType typeX) AndAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations) AnnotationPatternList.matches(ResolvedType[] someArgs) abstract FuzzyBooleanAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations) AnyAnnotationTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations) BindingAnnotationFieldTypePattern.matches(AnnotatedElement annotated, ResolvedType[] parameterAnnotations) booleanDeclareAnnotation.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) final FuzzyBooleanTypePattern.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 booleanAndTypePattern.matchesExactly(ResolvedType type) protected booleanAndTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanAnyTypePattern.matchesExactly(ResolvedType type) protected booleanAnyTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanAnyWithAnnotationTypePattern.matchesExactly(ResolvedType type) protected booleanAnyWithAnnotationTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanEllipsisTypePattern.matchesExactly(ResolvedType type) protected booleanEllipsisTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanExactTypePattern.matchesExactly(ResolvedType matchType) protected booleanExactTypePattern.matchesExactly(ResolvedType matchType, ResolvedType annotatedType) protected booleanHasMemberTypePattern.matchesExactly(ResolvedType type) protected booleanHasMemberTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanNotTypePattern.matchesExactly(ResolvedType type) protected booleanNotTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanNoTypePattern.matchesExactly(ResolvedType type) protected booleanNoTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanOrTypePattern.matchesExactly(ResolvedType type) protected booleanOrTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanTypeCategoryTypePattern.matchesExactly(ResolvedType type) protected booleanTypeCategoryTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected abstract booleanTypePattern.matchesExactly(ResolvedType type) protected abstract booleanTypePattern.matchesExactly(ResolvedType type, ResolvedType annotatedType) protected booleanWildTypePattern.matchesExactly(ResolvedType type) protected booleanWildTypePattern.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 FuzzyBooleanTypePattern.matchesInstanceof(ResolvedType type) WildTypePattern.matchesInstanceof(ResolvedType type) booleanAndTypePattern.matchesStatically(ResolvedType type) booleanNotTypePattern.matchesStatically(ResolvedType type) booleanOrTypePattern.matchesStatically(ResolvedType type) booleanTypePattern.matchesStatically(ResolvedType type) protected booleanAnyTypePattern.matchesSubtypes(ResolvedType type) protected booleanAnyWithAnnotationTypePattern.matchesSubtypes(ResolvedType type) protected booleanExactTypePattern.matchesSubtypes(ResolvedType type) protected booleanNoTypePattern.matchesSubtypes(ResolvedType type) protected booleanTypePattern.matchesSubtypes(ResolvedType type) protected booleanTypePattern.matchesSubtypes(ResolvedType superType, ResolvedType annotatedType) voidArgsPointcut.postRead(ResolvedType enclosingType) voidIfPointcut.IfFalsePointcut.postRead(ResolvedType enclosingType) voidIfPointcut.IfTruePointcut.postRead(ResolvedType enclosingType) voidKindedPointcut.postRead(ResolvedType enclosingType) voidPointcut.postRead(ResolvedType enclosingType) voidReferencePointcut.postRead(ResolvedType enclosingType) voidSignaturePattern.postRead(ResolvedType enclosingType) voidThisOrTargetPointcut.postRead(ResolvedType enclosingType) voidTypePattern.postRead(ResolvedType enclosingType) voidTypePatternList.postRead(ResolvedType enclosingType) voidWithincodePointcut.postRead(ResolvedType enclosingType) voidWithinPointcut.postRead(ResolvedType enclosingType) protected voidWildAnnotationTypePattern.resolveAnnotationValues(ResolvedType annotationType, IScope scope) Resolve any annotation values specified, checking they are all well formed (valid names, valid values)voidDeclareAnnotation.setAspect(ResolvedType typeX) voidExposedState.setConcreteAspect(ResolvedType concreteAspect) voidDeclare.setDeclaringType(ResolvedType aType) protected voidExactAnnotationTypePattern.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
Fields in org.aspectj.weaver.reflect declared as ResolvedTypeModifier and TypeFieldDescriptionstatic final ResolvedType[][]Java15AnnotationFinder.NO_PARAMETER_ANNOTATIONSMethods in org.aspectj.weaver.reflect that return ResolvedTypeModifier and TypeMethodDescriptionAnnotationFinder.getAnnotations(Member onMember, boolean runtimeAnnotationsOnly) Java15AnnotationFinder.getAnnotations(Class forClass, World inWorld) Java15AnnotationFinder.getAnnotations(Member onMember, boolean areRuntimeAnnotationsSufficient) Java15ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()ReflectionBasedResolvedMemberImpl.getAnnotationTypes()Java15ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()Java15ReflectionBasedReferenceTypeDelegate.getGenericResolvedType()Returns the generic type, regardless of the resolvedType we 'know about'Java15ReflectionBasedReferenceTypeDelegate.getOuterClass()ReflectionBasedReferenceTypeDelegate.getOuterClass()ResolvedType[][]AnnotationFinder.getParameterAnnotationTypes(Member onMember) ResolvedType[][]Java15AnnotationFinder.getParameterAnnotationTypes(Member onMember) ResolvedType[][]ReflectionBasedResolvedMemberImpl.getParameterAnnotationTypes()Java15ReflectionBasedReferenceTypeDelegate.getSuperclass()ReflectionBasedReferenceTypeDelegate.getSuperclass()static ResolvedTypestatic ResolvedTypeReflectionBasedReferenceTypeDelegateFactory.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 ReflectionVarReflectionVar.createArgsAnnotationVar(ResolvedType type, int index, AnnotationFinder finder) static ReflectionVarReflectionVar.createArgsVar(ResolvedType type, int index, AnnotationFinder finder) static ReflectionVarReflectionVar.createAtAnnotationVar(ResolvedType annType, AnnotationFinder finder) static ReflectionVarReflectionVar.createTargetAnnotationVar(ResolvedType type, AnnotationFinder finder) static ReflectionVarReflectionVar.createTargetVar(ResolvedType type, AnnotationFinder finder) static ReflectionVarReflectionVar.createThisAnnotationVar(ResolvedType type, AnnotationFinder finder) static ReflectionVarReflectionVar.createThisVar(ResolvedType type, AnnotationFinder finder) static ReflectionVarReflectionVar.createWithinAnnotationVar(ResolvedType annType, AnnotationFinder finder) static ReflectionVarReflectionVar.createWithinCodeAnnotationVar(ResolvedType annType, AnnotationFinder finder) AnnotationFinder.getAnnotation(ResolvedType annotationType, Object onObject) Java15AnnotationFinder.getAnnotation(ResolvedType annotationType, Object onObject) AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, Class<?> aClass) Java15AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType, Class aClass) AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, Member aMember) Java15AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType, Member aMember) ReflectionShadow.getThisAspectInstanceVar(ResolvedType aspectType) StandardShadow.getThisAspectInstanceVar(ResolvedType aspectType) static ShadowStandardShadow.makeStaticInitializationShadow(World inWorld, ResolvedType forType, MatchingContext withContext) voidStandardShadowMatchImpl.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.