Verwendungen von Klasse
org.aspectj.weaver.ResolvedType
Packages, die ResolvedType verwenden
Package
Beschreibung
-
Verwendungen von ResolvedType in org.aspectj.weaver
Unterklassen von ResolvedType in org.aspectj.weaverModifizierer und TypKlasseBeschreibungclassRepresents 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.Felder in org.aspectj.weaver, die deklariert sind als ResolvedTypeModifizierer und TypFeldBeschreibungprotected 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.typeMethoden in org.aspectj.weaver, die ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungResolvedType.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.Methoden in org.aspectj.weaver, die Typen mit Argumenten vom Typ ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungstatic 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()Methoden in org.aspectj.weaver mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungvoidCrosscuttingMembersSet.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) Konstruktoren in org.aspectj.weaver mit Parametern vom Typ ResolvedTypeModifiziererKonstruktorBeschreibungArrayReferenceType(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) -
Verwendungen von ResolvedType in org.aspectj.weaver.ast
Methoden in org.aspectj.weaver.ast, die ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungCallExpr.getType()abstract ResolvedTypeExpr.getType()FieldGet.getType()Var.getType()Methoden in org.aspectj.weaver.ast mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungVar.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) Konstruktoren in org.aspectj.weaver.ast mit Parametern vom Typ ResolvedTypeModifiziererKonstruktorBeschreibungCallExpr(Member m, Expr[] args, ResolvedType returnType) FieldGet(Member field, ResolvedType resolvedType) HasAnnotation(Var v, ResolvedType annType) Var(ResolvedType variableType) -
Verwendungen von ResolvedType in org.aspectj.weaver.bcel
Felder in org.aspectj.weaver.bcel, die deklariert sind als ResolvedTypeMethoden in org.aspectj.weaver.bcel, die ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungBcelWeaver.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) Methoden in org.aspectj.weaver.bcel mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungvoidLazyClassGen.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.Konstruktoren in org.aspectj.weaver.bcel mit Parametern vom Typ ResolvedTypeModifiziererKonstruktorBeschreibungAnnotationAccessVar(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) -
Verwendungen von ResolvedType in org.aspectj.weaver.internal.tools
Methoden in org.aspectj.weaver.internal.tools mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungprotected PointcutPointcutDesignatorHandlerBasedPointcut.concretize1(ResolvedType inAspect, ResolvedType declaringType, IntMap bindings) StandardPointcutExpressionImpl.matchesStaticInitialization(ResolvedType aType) -
Verwendungen von ResolvedType in org.aspectj.weaver.ltw
Methoden in org.aspectj.weaver.ltw, die ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungprotected ResolvedTypeLTWWorld.completeNonLocalType(ResolvedType ret) Methoden in org.aspectj.weaver.ltw mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungprotected voidLTWWorld.completeBinaryType(ResolvedType ret) protected ResolvedTypeLTWWorld.completeNonLocalType(ResolvedType ret) -
Verwendungen von ResolvedType in org.aspectj.weaver.model
Methoden in org.aspectj.weaver.model mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungstatic 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). -
Verwendungen von ResolvedType in org.aspectj.weaver.patterns
Felder in org.aspectj.weaver.patterns, die deklariert sind als ResolvedTypeModifizierer und TypFeldBeschreibungprotected ResolvedTypePerClause.inAspectprotected ResolvedTypeExactTypePattern.resolvedTypeMethoden in org.aspectj.weaver.patterns, die ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungDeclareAnnotation.getAnnotationType()ExposedState.getConcreteAspect()Declare.getDeclaringType()IScope.getEnclosingType()ScopeWithTypeVariables.getEnclosingType()SimpleScope.getEnclosingType()ExactAnnotationFieldTypePattern.getResolvedAnnotationType()ExactAnnotationTypePattern.getResolvedAnnotationType()ExactTypePattern.getResolvedExactType(World world) FastMatchInfo.getType()Methoden in org.aspectj.weaver.patterns, die Typen mit Argumenten vom Typ ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungDeclareParents.findMatchingNewParents(ResolvedType onType, boolean reportErrors) Methoden in org.aspectj.weaver.patterns mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungTypePatternQuestions.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) Konstruktoren in org.aspectj.weaver.patterns mit Parametern vom Typ ResolvedTypeModifiziererKonstruktorBeschreibungConcreteCflowPointcut(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) -
Verwendungen von ResolvedType in org.aspectj.weaver.reflect
Felder in org.aspectj.weaver.reflect, die deklariert sind als ResolvedTypeModifizierer und TypFeldBeschreibungstatic final ResolvedType[][]Java15AnnotationFinder.NO_PARAMETER_ANNOTATIONSMethoden in org.aspectj.weaver.reflect, die ResolvedType zurückgebenModifizierer und TypMethodeBeschreibungAnnotationFinder.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.Methoden in org.aspectj.weaver.reflect mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungstatic 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) Konstruktoren in org.aspectj.weaver.reflect mit Parametern vom Typ ResolvedTypeModifiziererKonstruktorBeschreibungReflectionFastMatchInfo(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) -
Verwendungen von ResolvedType in org.aspectj.weaver.tools
Methoden in org.aspectj.weaver.tools mit Parametern vom Typ ResolvedTypeModifizierer und TypMethodeBeschreibungStandardPointcutExpression.matchesStaticInitialization(ResolvedType aType) Determine whether or not this pointcut matches the static initialization of the given class.