|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of ResolvedType in org.aspectj.weaver |
---|
Subclasses of ResolvedType in org.aspectj.weaver | |
---|---|
class |
ArrayReferenceType
Represents a resolved array type |
class |
BoundedReferenceType
A BoundedReferenceType is the result of a generics wildcard expression ? extends String, ? super Foo etc.. |
class |
MissingResolvedTypeWithKnownSignature
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 |
ReferenceType
A reference type represents some 'real' type, not a primitive, not an array - but a real type, for example java.util.List. |
class |
TypeVariableReferenceType
ReferenceType representing a type variable. |
Fields in org.aspectj.weaver declared as ResolvedType | |
---|---|
static ResolvedType[] |
ResolvedType.EMPTY_ARRAY
|
static ResolvedType[] |
ResolvedType.EMPTY_RESOLVED_TYPE_ARRAY
|
static ResolvedType[][] |
Member.NO_PARAMETER_ANNOTATION_TYPES
|
static ResolvedType[] |
ResolvedType.NONE
|
ResolvedType[] |
ResolvedType.temporaryAnnotationTypes
|
Methods in org.aspectj.weaver that return ResolvedType | |
---|---|
ResolvedType |
ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
Look up the actual occurence of a particular type in the hierarchy for 'this' type. |
ResolvedType |
CrosscuttingMembersSet.findAspectDeclaringParents(DeclareParents p)
|
ResolvedType |
World.TypeMap.get(java.lang.String key)
Lookup a type by its signature, always look in the real map before the expendable map |
ResolvedType[] |
AnnotatedElement.getAnnotationTypes()
|
ResolvedType[] |
ArrayReferenceType.getAnnotationTypes()
|
ResolvedType[] |
ResolvedType.getAnnotationTypes()
|
ResolvedType[] |
ResolvedMember.getAnnotationTypes()
|
ResolvedType[] |
ResolvedMemberImpl.getAnnotationTypes()
|
ResolvedType[] |
GeneratedReferenceTypeDelegate.getAnnotationTypes()
|
ResolvedType[] |
ReferenceType.getAnnotationTypes()
|
ResolvedType[] |
ReferenceTypeDelegate.getAnnotationTypes()
|
ResolvedType[] |
JoinPointSignature.getAnnotationTypes()
|
ResolvedType[] |
Shadow.getArgumentTypesForArrayConstructionShadow()
|
ResolvedType |
ConcreteTypeMunger.getAspectType()
|
ResolvedType |
Advice.getConcreteAspect()
|
abstract ResolvedType |
ShadowMunger.getConcreteAspect()
|
ResolvedType |
Checker.getConcreteAspect()
|
ResolvedType |
IntMap.getConcreteAspect()
|
ResolvedType |
World.getCoreType(UnresolvedType tx)
Special resolution for "core" types like OBJECT. |
ResolvedType[] |
ArrayReferenceType.getDeclaredInterfaces()
|
abstract ResolvedType[] |
ResolvedType.getDeclaredInterfaces()
|
ResolvedType[] |
MissingResolvedTypeWithKnownSignature.getDeclaredInterfaces()
|
ResolvedType[] |
GeneratedReferenceTypeDelegate.getDeclaredInterfaces()
|
ResolvedType[] |
ReferenceType.getDeclaredInterfaces()
Find out from the generic signature the true signature of any interfaces I implement. |
ResolvedType[] |
ReferenceTypeDelegate.getDeclaredInterfaces()
|
ResolvedType[] |
BoundedReferenceType.getDeclaredInterfaces()
|
ResolvedType |
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. |
ResolvedType |
ShadowMunger.getDeclaringType()
|
ResolvedType |
NewParentTypeMunger.getDeclaringType()
|
ResolvedType |
BindingScope.getEnclosingType()
|
ResolvedType |
ResolvedType.getGenericType()
Overridden by ReferenceType to return a sensible answer for parameterized and raw types. |
ResolvedType |
ReferenceType.getGenericType()
|
ResolvedType |
NewParentTypeMunger.getNewParent()
|
ResolvedType |
GeneratedReferenceTypeDelegate.getOuterClass()
|
ResolvedType |
ReferenceType.getOuterClass()
|
ResolvedType |
ReferenceTypeDelegate.getOuterClass()
|
ResolvedType[][] |
ResolvedMember.getParameterAnnotationTypes()
|
ResolvedType[][] |
ResolvedMemberImpl.getParameterAnnotationTypes()
|
ResolvedType[][] |
JoinPointSignature.getParameterAnnotationTypes()
|
ResolvedType |
ResolvedType.getRawType()
|
ResolvedType |
ResolvableTypeList.getResolved(int nameIndex)
|
ResolvedType |
ArrayReferenceType.getResolvedComponentType()
|
ResolvedType |
ResolvedType.getResolvedComponentType()
|
ResolvedType[] |
ResolvedType.getResolvedTypeParameters()
|
ResolvedType |
ArrayReferenceType.getSuperclass()
|
abstract ResolvedType |
ResolvedType.getSuperclass()
|
ResolvedType |
MissingResolvedTypeWithKnownSignature.getSuperclass()
|
ResolvedType |
GeneratedReferenceTypeDelegate.getSuperclass()
|
ResolvedType |
ReferenceType.getSuperclass()
|
ResolvedType |
ReferenceTypeDelegate.getSuperclass()
|
ResolvedType |
ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
|
ResolvedType |
AnnotationAJ.getType()
|
ResolvedType |
AbstractAnnotationAJ.getType()
|
static ResolvedType |
ResolvedType.makeArray(ResolvedType type,
int dim)
|
ResolvedType |
Iterators.ResolvedTypeArrayIterator.next()
|
ResolvedType |
ResolvedType.parameterizedWith(UnresolvedType[] typeParameters)
|
ResolvedType |
World.TypeMap.put(java.lang.String key,
ResolvedType type)
Add a new type into the map, the key is the type signature. |
ResolvedType |
World.TypeMap.remove(java.lang.String key)
Remove a type from the map |
ResolvedType |
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. |
ResolvedType |
World.resolve(java.lang.String name)
Convenience method for finding a type by name and resolving it in one step. |
ResolvedType |
World.resolve(java.lang.String name,
boolean allowMissing)
|
ResolvedType |
World.resolve(UnresolvedType ty)
Resolve a type that we require to be present in the world |
ResolvedType[] |
World.resolve(UnresolvedType[] types)
Convenience method for resolving an array of unresolved types in one hit. |
ResolvedType |
World.resolve(UnresolvedType ty,
boolean allowMissing)
Resolve a type. |
ResolvedType |
World.resolve(UnresolvedType ty,
ISourceLocation isl)
Attempt to resolve a type - the source location gives you some context in which resolution is taking place. |
ResolvedType |
UnresolvedType.resolve(World world)
Returns a resolved version of this type according to a particular world. |
ResolvedType |
UnresolvedTypeVariableReferenceType.resolve(World world)
|
ResolvedType |
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 ResolvedType | |
---|---|
static java.util.Iterator<ResolvedType> |
Iterators.array(ResolvedType[] o,
boolean genericsAware)
|
java.util.Collection<ResolvedType> |
Member.getDeclaringTypes(World world)
|
java.util.Collection<ResolvedType> |
MemberImpl.getDeclaringTypes(World world)
|
java.util.Collection<ResolvedType> |
JoinPointSignature.getDeclaringTypes(World world)
|
java.util.Iterator<ResolvedType> |
ResolvedType.getDirectSupertypes()
Returns an iterator through ResolvedType objects representing all the direct supertypes of this type. |
java.util.Map<ResolvedType,java.util.Set<ResolvedType>> |
World.getExclusionMap()
|
java.util.Map<ResolvedType,java.util.Set<ResolvedType>> |
World.getExclusionMap()
|
java.util.Map<java.lang.String,java.lang.ref.Reference<ResolvedType>> |
World.getExpendable()
|
java.util.Map<java.lang.String,java.lang.ref.Reference<ResolvedType>> |
World.TypeMap.getExpendableMap()
|
java.util.Map<java.lang.String,ResolvedType> |
World.getFixed()
|
java.util.Iterator<ResolvedType> |
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). |
java.util.Iterator<ResolvedType> |
ResolvedType.getHierarchy(boolean wantGenerics,
boolean wantDeclaredParents)
|
java.util.List<ResolvedType> |
ResolvedType.getHierarchyWithoutIterator(boolean includeITDs,
boolean allowMissing,
boolean genericsAware)
Return a list of the types in the hierarchy of this type, starting with this type. |
java.util.Map<java.lang.String,ResolvedType> |
World.TypeMap.getMainMap()
|
abstract java.util.Collection<ResolvedType> |
ShadowMunger.getThrownExceptions()
|
java.util.Collection<ResolvedType> |
Checker.getThrownExceptions()
|
Methods in org.aspectj.weaver with parameters of type ResolvedType | |
---|---|
void |
CrosscuttingMembersSet.addAdviceLikeDeclares(ResolvedType aspectType)
|
void |
CrosscuttingMembersSet.addFixedCrosscuttingMembers(ResolvedType aspectType)
|
boolean |
CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType)
|
boolean |
CrosscuttingMembersSet.addOrReplaceAspect(ResolvedType aspectType,
boolean inWeavingPhase)
|
void |
ResolvedType.addParent(ResolvedType newParent)
|
void |
ReferenceType.addParent(ResolvedType newParent)
|
boolean |
BoundedReferenceType.alwaysMatches(ResolvedType aCandidateType)
|
static java.util.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.checkLegalOverride(ResolvedMember parent,
ResolvedMember child,
int transformerPosition,
ResolvedType aspectType)
|
int |
World.compareByPrecedence(ResolvedType aspect1,
ResolvedType aspect2)
Same signature as org.aspectj.util.PartialOrder.PartialComparable.compareTo |
int |
World.compareByPrecedenceAndHierarchy(ResolvedType aspect1,
ResolvedType aspect2)
compares by precedence with the additional rule that a super-aspect is sorted before its sub-aspects |
ConcreteTypeMunger |
IWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger,
ResolvedType aspectType)
|
ShadowMunger |
Advice.concretize(ResolvedType fromType,
World world,
PerClause clause)
|
abstract ShadowMunger |
ShadowMunger.concretize(ResolvedType fromType,
World world,
PerClause clause)
|
ShadowMunger |
Checker.concretize(ResolvedType theAspect,
World world,
PerClause clause)
Concretize this Checker by concretizing the pointcut |
ConcreteTypeMunger |
IWeavingSupport.createAccessForInlineMunger(ResolvedType inAspect)
|
Advice |
World.createAdviceMunger(AdviceKind kind,
Pointcut p,
Member signature,
int extraParameterFlags,
IHasSourceLocation loc,
ResolvedType declaringAspect)
Create an advice shadow munger for the given advice kind |
Advice |
IWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute,
Pointcut pointcut,
Member signature,
ResolvedType concreteAspect)
|
java.util.Collection<ShadowMunger> |
CustomMungerFactory.createCustomShadowMungers(ResolvedType aspectType)
|
java.util.Collection<ConcreteTypeMunger> |
CustomMungerFactory.createCustomTypeMungers(ResolvedType aspectType)
|
static ReferenceType |
TypeFactory.createParameterizedType(ResolvedType aBaseType,
UnresolvedType[] someTypeParameters,
World inAWorld)
Create a parameterized version of a generic type. |
ResolvedType |
ResolvedType.discoverActualOccurrenceOfTypeInHierarchy(ResolvedType lookingFor)
Look up the actual occurence of a particular type in the hierarchy for 'this' type. |
TypePattern |
World.getAspectScope(ResolvedType declaringType)
|
ResolvedMember |
MethodDelegateTypeMunger.getDelegate(ResolvedType targetType)
|
ResolvedMember |
NewMethodTypeMunger.getMatchingSyntheticMember(Member member,
ResolvedType aspectType)
|
ResolvedMember |
NewFieldTypeMunger.getMatchingSyntheticMember(Member member,
ResolvedType aspectType)
|
ResolvedMember |
ResolvedTypeMunger.getMatchingSyntheticMember(Member member,
ResolvedType aspectType)
|
ResolvedMember |
PrivilegedAccessMunger.getMatchingSyntheticMember(Member member,
ResolvedType aspectType)
|
ResolvedMember |
NewConstructorTypeMunger.getMatchingSyntheticMember(Member member,
ResolvedType aspectType)
|
java.lang.Integer |
World.getPrecedenceIfAny(ResolvedType aspect1,
ResolvedType aspect2)
|
ResolvedType |
ResolvedType.getTopmostImplementor(ResolvedType interfaceType)
|
java.util.List<ConcreteTypeMunger> |
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 implementors |
static 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 implementors |
boolean |
WeaverStateInfo.isAspectAlreadyApplied(ResolvedType someAspect)
|
boolean |
World.isAspectIncluded(ResolvedType aspectType)
|
boolean |
ArrayReferenceType.isAssignableFrom(ResolvedType o)
|
abstract boolean |
ResolvedType.isAssignableFrom(ResolvedType other)
Determines if the variables of this type could be assigned values of another type without casting. |
boolean |
MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other)
|
boolean |
ReferenceType.isAssignableFrom(ResolvedType other)
|
boolean |
ArrayReferenceType.isAssignableFrom(ResolvedType o,
boolean allowMissing)
|
abstract boolean |
ResolvedType.isAssignableFrom(ResolvedType other,
boolean allowMissing)
|
boolean |
MissingResolvedTypeWithKnownSignature.isAssignableFrom(ResolvedType other,
boolean allowMissing)
|
boolean |
ReferenceType.isAssignableFrom(ResolvedType other,
boolean allowMissing)
|
boolean |
ArrayReferenceType.isCoerceableFrom(ResolvedType o)
|
abstract boolean |
ResolvedType.isCoerceableFrom(ResolvedType other)
Determines if values of another type could possibly be cast to this type. |
boolean |
MissingResolvedTypeWithKnownSignature.isCoerceableFrom(ResolvedType other)
|
boolean |
ReferenceType.isCoerceableFrom(ResolvedType o)
|
boolean |
ResolvedType.isConvertableFrom(ResolvedType other)
Determines if variables of this type could be assigned values of another with lots of help. |
boolean |
ResolvedType.isTopmostImplementor(ResolvedType interfaceType)
|
static boolean |
ResolvedType.isVisible(int modifiers,
ResolvedType targetType,
ResolvedType fromType)
|
boolean |
ResolvedMember.isVisible(ResolvedType fromType)
|
boolean |
ResolvedMemberImpl.isVisible(ResolvedType fromType)
|
boolean |
JoinPointSignature.isVisible(ResolvedType fromType)
|
static ResolvedMember |
AjcMemberMaker.itdAtDeclareParentsField(ResolvedType targetType,
UnresolvedType itdType,
UnresolvedType aspectType)
|
static ResolvedType |
ResolvedType.makeArray(ResolvedType type,
int dim)
|
Var |
IWeavingSupport.makeCflowAccessVar(ResolvedType formalType,
Member cflowField,
int arrayIndex)
|
static Advice |
Advice.makeCflowEntry(World world,
Pointcut entry,
boolean isBelow,
Member stackField,
int nFreeVars,
java.util.List<ShadowMunger> innerCflowEntries,
ResolvedType inAspect)
|
static Advice |
Advice.makePerCflowEntry(World world,
Pointcut entry,
boolean isBelow,
Member stackField,
ResolvedType inAspect,
java.util.List<ShadowMunger> innerCflowEntries)
|
ConcreteTypeMunger |
IWeavingSupport.makePerClauseAspect(ResolvedType aspect,
PerClause.Kind kind)
Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as needed |
static 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 |
ResolvedTypeMunger.matches(ResolvedType matchType,
ResolvedType aspectType)
|
boolean |
PerTypeWithinTargetTypeMunger.matches(ResolvedType matchType,
ResolvedType aspectType)
|
boolean |
MethodDelegateTypeMunger.matches(ResolvedType matchType,
ResolvedType aspectType)
Match based on given type pattern, only classes can be matched |
boolean |
MethodDelegateTypeMunger.FieldHostTypeMunger.matches(ResolvedType matchType,
ResolvedType aspectType)
Match based on given type pattern, only classes can be matched |
boolean |
PerObjectInterfaceTypeMunger.matches(ResolvedType matchType,
ResolvedType aspectType)
|
boolean |
ResolvedType.needsNoConversionFrom(ResolvedType o)
|
ResolvedTypeMunger |
NewMethodTypeMunger.parameterizedFor(ResolvedType target)
see ResolvedTypeMunger.parameterizedFor(ResolvedType) |
ResolvedTypeMunger |
NewFieldTypeMunger.parameterizedFor(ResolvedType target)
see ResolvedTypeMunger.parameterizedFor(ResolvedType) |
ResolvedTypeMunger |
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.parameterizedFor |
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. |
ConcreteTypeMunger |
TemporaryTypeMunger.parameterizedFor(ResolvedType targetType)
|
ResolvedTypeMunger |
NewConstructorTypeMunger.parameterizedFor(ResolvedType target)
see ResolvedTypeMunger.parameterizedFor(ResolvedType) |
ResolvedMemberImpl |
ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized)
|
ResolvedMemberImpl |
ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized)
|
ResolvedMemberImpl |
JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized)
|
ResolvedMemberImpl |
ResolvedPointcutDefinition.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized)
Called when asking a parameterized super-aspect for its pointcuts. |
ResolvedMemberImpl |
ResolvedMember.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized,
java.util.List<java.lang.String> aliases)
|
ResolvedMemberImpl |
ResolvedMemberImpl.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized,
java.util.List<java.lang.String> aliases)
Return a resolvedmember in which all the type variables in the signature have been replaced with the given bindings. |
ResolvedMemberImpl |
JoinPointSignature.parameterizedWith(UnresolvedType[] typeParameters,
ResolvedType newDeclaringType,
boolean isParameterized,
java.util.List<java.lang.String> aliases)
|
abstract ShadowMunger |
ShadowMunger.parameterizeWith(ResolvedType declaringType,
java.util.Map<java.lang.String,UnresolvedType> typeVariableMap)
|
ShadowMunger |
Checker.parameterizeWith(ResolvedType declaringType,
java.util.Map<java.lang.String,UnresolvedType> typeVariableMap)
Parameterize the Checker by parameterizing the pointcut |
static ResolvedMember |
AjcMemberMaker.perObjectField(UnresolvedType declaringType,
ResolvedType aspectType)
|
static ResolvedMember |
AjcMemberMaker.perTypeWithinField(UnresolvedType declaringType,
ResolvedType aspectType)
|
static ResolvedMember |
AjcMemberMaker.perTypeWithinWithinTypeField(UnresolvedType declaringType,
ResolvedType aspectType)
|
ResolvedType |
World.TypeMap.put(java.lang.String key,
ResolvedType type)
Add a new type into the map, the key is the type signature. |
Advice |
AjAttribute.AdviceAttribute.reify(Member signature,
World world,
ResolvedType concreteAspect)
|
PerClause |
AjAttribute.Aspect.reify(ResolvedType inAspect)
|
ConcreteTypeMunger |
AjAttribute.TypeMunger.reify(World world,
ResolvedType aspectType)
|
PerClause |
AjAttribute.Aspect.reifyFromAtAspectJ(ResolvedType inAspect)
|
ResolvedType |
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 |
ResolvedMember.setAnnotationTypes(ResolvedType[] annotationtypes)
|
void |
ResolvedMemberImpl.setAnnotationTypes(ResolvedType[] annotationTypes)
|
void |
JoinPointSignature.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 ResolvedType | |
---|---|
AbstractAnnotationAJ(ResolvedType type)
|
|
ArrayReferenceType(java.lang.String sig,
java.lang.String erasureSig,
World world,
ResolvedType componentType)
|
|
BindingScope(ResolvedType type,
ISourceContext sourceContext,
FormalBinding[] bindings)
|
|
ConcreteTypeMunger(ResolvedTypeMunger munger,
ResolvedType aspectType)
|
|
CrosscuttingMembers(ResolvedType inAspect,
boolean shouldConcretizeIfNeeded)
|
|
Iterators.ResolvedTypeArrayIterator(ResolvedType[] array,
java.util.List<java.lang.String> alreadySeen,
boolean wantGenerics)
|
|
JoinPointSignature(ResolvedMember backing,
ResolvedType aType)
|
|
NewParentTypeMunger(ResolvedType newParent,
ResolvedType declaringType)
|
|
ReferenceType(ResolvedType theGenericType,
ResolvedType[] theParameters,
World aWorld)
Constructor used when creating a parameterized type. |
|
ReferenceType(ResolvedType theGenericType,
ResolvedType[] theParameters,
World aWorld)
Constructor used when creating a parameterized type. |
|
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 ResolvedType | |
---|---|
ResolvedType |
Var.getType()
|
ResolvedType |
FieldGet.getType()
|
abstract ResolvedType |
Expr.getType()
|
ResolvedType |
CallExpr.getType()
|
Methods in org.aspectj.weaver.ast with parameters of type ResolvedType | |
---|---|
Var |
Var.getAccessorForValue(ResolvedType formalType)
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 ResolvedType | |
---|---|
CallExpr(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 ResolvedType | |
---|---|
ResolvedType |
LazyMethodGen.definingType
|
Methods in org.aspectj.weaver.bcel that return ResolvedType | |
---|---|
ResolvedType |
BcelWeaver.addLibraryAspect(java.lang.String aspectName)
Add the given aspect to the weaver. |
static ResolvedType |
BcelGenericSignatureToTypeXConverter.classTypeSignature2TypeX(GenericSignature.ClassTypeSignature aClassTypeSignature,
GenericSignature.FormalTypeParameter[] typeParams,
World world)
|
static ResolvedType |
BcelGenericSignatureToTypeXConverter.fieldTypeSignature2TypeX(GenericSignature.FieldTypeSignature aFieldTypeSignature,
GenericSignature.FormalTypeParameter[] typeParams,
World world)
|
ResolvedType[] |
BcelObjectType.getAnnotationTypes()
|
ResolvedType[] |
BcelObjectType.getDeclaredInterfaces()
Retrieves the declared interfaces - this allows for the generic signature on a type. |
ResolvedType |
BcelShadow.getEnclosingType()
|
ResolvedType |
BcelObjectType.getOuterClass()
|
ResolvedType |
BcelObjectType.getSuperclass()
Must take into account generic signature |
ResolvedType |
LazyClassGen.getSuperClass()
|
ResolvedType |
LazyClassGen.getType()
|
ResolvedType |
BcelWorld.resolve(Type t)
|
static ResolvedType |
BcelGenericSignatureToTypeXConverter.typeSignature2TypeX(GenericSignature.TypeSignature aTypeSig,
GenericSignature.FormalTypeParameter[] typeParams,
World world)
|
Methods in org.aspectj.weaver.bcel with parameters of type ResolvedType | |
---|---|
void |
LazyClassGen.addInterface(ResolvedType newInterface,
ISourceLocation sourceLocation)
|
static void |
Utility.appendConversion(InstructionList il,
InstructionFactory fact,
ResolvedType fromType,
ResolvedType toType)
|
void |
BcelCflowAccessVar.appendLoadAndConvert(InstructionList il,
InstructionFactory fact,
ResolvedType toType)
|
void |
TypeAnnotationAccessVar.appendLoadAndConvert(InstructionList il,
InstructionFactory fact,
ResolvedType toType)
|
void |
AnnotationAccessVar.appendLoadAndConvert(InstructionList il,
InstructionFactory fact,
ResolvedType toType)
|
void |
BcelVar.appendLoadAndConvert(InstructionList il,
InstructionFactory fact,
ResolvedType toType)
|
boolean |
BcelTypeMunger.attemptToModifySuperCalls(org.aspectj.weaver.bcel.BcelClassWeaver weaver,
LazyClassGen newParentTarget,
ResolvedType newParent)
The main part of implementing declare parents extends. |
ConcreteTypeMunger |
BcelWeavingSupport.concreteTypeMunger(ResolvedTypeMunger munger,
ResolvedType aspectType)
|
ConcreteTypeMunger |
BcelWeavingSupport.createAccessForInlineMunger(ResolvedType aspect)
|
Advice |
BcelWeavingSupport.createAdviceMunger(AjAttribute.AdviceAttribute attribute,
Pointcut pointcut,
Member signature,
ResolvedType concreteAspect)
|
InstructionList |
BcelCflowAccessVar.createLoadInstructions(ResolvedType toType,
InstructionFactory fact)
|
InstructionList |
TypeAnnotationAccessVar.createLoadInstructions(ResolvedType toType,
InstructionFactory fact)
|
Var |
AnnotationAccessVar.getAccessorForValue(ResolvedType valueType)
Return an object that can access a particular value of this annotation. |
Field |
LazyClassGen.getAnnotationCachingField(BcelShadow shadow,
ResolvedType toType)
Create a field in the type containing the shadow where the annotation retrieved during binding can be stored - for later fast access. |
TypePattern |
BcelWorld.getAspectScope(ResolvedType declaringType)
|
static BcelObjectType |
BcelWorld.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. |
static boolean |
LazyClassGen.hasSerialVersionUIDField(ResolvedType type)
|
boolean |
BcelWorld.hasUnsatisfiedDependency(ResolvedType aspectType)
|
boolean |
BcelWorld.isAspectIncluded(ResolvedType aspectType)
|
Var |
BcelWeavingSupport.makeCflowAccessVar(ResolvedType formalType,
Member cflowField,
int arrayIndex)
|
ConcreteTypeMunger |
BcelWeavingSupport.makePerClauseAspect(ResolvedType aspect,
PerClause.Kind kind)
Register a munger for perclause @AJ aspect so that we add aspectOf(..) to them as needed |
boolean |
BcelCflowCounterFieldAdder.matches(ResolvedType onType)
|
boolean |
BcelAccessForInlineMunger.matches(ResolvedType onType)
Match only the aspect for which we act |
boolean |
BcelCflowStackFieldAdder.matches(ResolvedType onType)
|
boolean |
BcelPerClauseAspectAdder.matches(ResolvedType onType)
|
ConcreteTypeMunger |
BcelTypeMunger.parameterizedFor(ResolvedType target)
|
static BcelVar[] |
Utility.pushAndReturnArrayOfVars(ResolvedType[] proceedParamTypes,
InstructionList il,
InstructionFactory fact,
LazyMethodGen enclosingMethod)
|
static java.util.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 java.util.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. |
void |
LazyClassGen.setSuperClass(ResolvedType newSuperclass)
|
void |
BcelWeaver.weaveNormalTypeMungers(ResolvedType onType)
|
void |
BcelWeaver.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 ResolvedType | |
---|---|
AnnotationAccessVar(BcelShadow shadow,
Shadow.Kind kind,
ResolvedType annotationType,
UnresolvedType theTargetIsStoredHere,
Member sig)
|
|
BcelAccessForInlineMunger(ResolvedType aspectType)
|
|
BcelAnnotation(AnnotationGen theBcelAnnotation,
ResolvedType resolvedAnnotationType)
|
|
BcelCflowAccessVar(ResolvedType type,
Member stackField,
int index)
|
|
BcelFieldRef(ResolvedType type,
java.lang.String className,
java.lang.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 ResolvedType | |
---|---|
ShadowMatch |
StandardPointcutExpressionImpl.matchesStaticInitialization(ResolvedType aType)
|
Uses of ResolvedType in org.aspectj.weaver.ltw |
---|
Methods in org.aspectj.weaver.ltw that return ResolvedType | |
---|---|
ResolvedType |
LTWWorld.resolve(java.lang.Class aClass)
|
Uses of ResolvedType in org.aspectj.weaver.model |
---|
Methods in org.aspectj.weaver.model with parameters of type ResolvedType | |
---|---|
static void |
AsmRelationshipProvider.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 |
---|
Methods in org.aspectj.weaver.patterns that return ResolvedType | |
---|---|
ResolvedType |
DeclareAnnotation.getAnnotationType()
|
ResolvedType |
Declare.getDeclaringType()
|
ResolvedType |
SimpleScope.getEnclosingType()
|
ResolvedType |
ScopeWithTypeVariables.getEnclosingType()
|
ResolvedType |
IScope.getEnclosingType()
|
ResolvedType |
ExactAnnotationFieldTypePattern.getResolvedAnnotationType()
|
ResolvedType |
ExactAnnotationTypePattern.getResolvedAnnotationType()
|
ResolvedType |
ExactTypePattern.getResolvedExactType(World world)
|
ResolvedType |
FastMatchInfo.getType()
|
Methods in org.aspectj.weaver.patterns that return types with arguments of type ResolvedType | |
---|---|
java.util.List<ResolvedType> |
DeclareParents.findMatchingNewParents(ResolvedType onType,
boolean reportErrors)
|
Methods in org.aspectj.weaver.patterns with parameters of type ResolvedType | |
---|---|
FuzzyBoolean |
TypePatternQuestions.askQuestion(TypePattern pattern,
ResolvedType type,
TypePattern.MatchKind kind)
|
int |
DeclarePrecedence.compare(ResolvedType aspect1,
ResolvedType aspect2)
|
PerClause |
PerCflow.concretize(ResolvedType inAspect)
|
PerClause |
PerFromSuper.concretize(ResolvedType inAspect)
|
PerClause |
PerTypeWithin.concretize(ResolvedType inAspect)
|
abstract PerClause |
PerClause.concretize(ResolvedType inAspect)
|
PerClause |
PerSingleton.concretize(ResolvedType inAspect)
|
PerClause |
PerObject.concretize(ResolvedType inAspect)
|
Pointcut |
Pointcut.concretize(ResolvedType inAspect,
ResolvedType declaringType,
int arity)
Returns a new pointcut Only used by test cases |
Pointcut |
Pointcut.concretize(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
Pointcut.concretize(ResolvedType inAspect,
ResolvedType declaringType,
int arity,
ShadowMunger advice)
|
Pointcut |
NotPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
CflowPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
ConcreteCflowPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
OrPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
ThisOrTargetPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
ArgsPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
IfPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
IfPointcut.IfFalsePointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
IfPointcut.IfTruePointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
KindedPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
PerClause.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
ReferencePointcut.concretize1(ResolvedType searchStart,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
WithincodePointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
WithinPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
AndPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
Pointcut |
HandlerPointcut.concretize1(ResolvedType inAspect,
ResolvedType declaringType,
IntMap bindings)
|
void |
DeclareAnnotation.copyAnnotationTo(ResolvedType onType)
|
boolean |
OrSignaturePattern.couldEverMatch(ResolvedType type)
|
boolean |
ISignaturePattern.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 |
AndSignaturePattern.couldEverMatch(ResolvedType type)
|
boolean |
NotSignaturePattern.couldEverMatch(ResolvedType type)
|
boolean |
SignaturePattern.couldEverMatch(ResolvedType type)
|
boolean |
SignaturePattern.declaringTypeMatchAllowingForCovariance(Member member,
UnresolvedType shadowDeclaringType,
World world,
TypePattern returnTypePattern,
ResolvedType sigReturn)
|
java.util.List<ResolvedType> |
DeclareParents.findMatchingNewParents(ResolvedType onType,
boolean reportErrors)
|
PerClause |
PerFromSuper.lookupConcretePerClause(ResolvedType lookupType)
|
boolean |
DeclareParents.match(ResolvedType typeX)
|
abstract FuzzyBoolean |
AnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
ExactAnnotationFieldTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
AnyAnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
OrAnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
WildAnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
AndAnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
BindingAnnotationFieldTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
ExactAnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
NotAnnotationTypePattern.matches(AnnotatedElement annotated,
ResolvedType[] parameterAnnotations)
|
FuzzyBoolean |
TypePatternList.matches(ResolvableTypeList types,
TypePattern.MatchKind kind,
ResolvedType[][] parameterAnnotations)
|
boolean |
DeclareAnnotation.matches(ResolvedType type)
For declare atType. |
FuzzyBoolean |
AnnotationPatternList.matches(ResolvedType[] someArgs)
|
FuzzyBoolean |
TypePatternList.matches(ResolvedType[] types,
TypePattern.MatchKind kind)
|
FuzzyBoolean |
TypePatternList.matches(ResolvedType[] types,
TypePattern.MatchKind kind,
ResolvedType[][] parameterAnnotations)
When called with TypePattern.STATIC this will always return either FuzzyBoolean.YES or FuzzyBoolean.NO. |
FuzzyBoolean |
TypePatternList.matches(ResolvedType[] types,
TypePattern.MatchKind kind,
ResolvedType[][] parameterAnnotations)
When called with TypePattern.STATIC this will always return either FuzzyBoolean.YES or FuzzyBoolean.NO. |
FuzzyBoolean |
TypePattern.matches(ResolvedType type,
TypePattern.MatchKind kind)
|
FuzzyBoolean |
NotTypePattern.matchesInstanceof(ResolvedType type)
|
abstract FuzzyBoolean |
TypePattern.matchesInstanceof(ResolvedType type)
|
FuzzyBoolean |
WildTypePattern.matchesInstanceof(ResolvedType type)
|
FuzzyBoolean |
OrTypePattern.matchesInstanceof(ResolvedType type)
|
FuzzyBoolean |
TypeCategoryTypePattern.matchesInstanceof(ResolvedType type)
|
FuzzyBoolean |
ExactTypePattern.matchesInstanceof(ResolvedType matchType)
|
FuzzyBoolean |
HasMemberTypePattern.matchesInstanceof(ResolvedType type)
|
FuzzyBoolean |
AndTypePattern.matchesInstanceof(ResolvedType type)
|
boolean |
NotTypePattern.matchesStatically(ResolvedType type)
|
boolean |
TypePattern.matchesStatically(ResolvedType type)
|
boolean |
OrTypePattern.matchesStatically(ResolvedType type)
|
boolean |
AndTypePattern.matchesStatically(ResolvedType type)
|
void |
TypePattern.postRead(ResolvedType enclosingType)
|
void |
Pointcut.postRead(ResolvedType enclosingType)
|
void |
ThisOrTargetPointcut.postRead(ResolvedType enclosingType)
|
void |
ArgsPointcut.postRead(ResolvedType enclosingType)
|
void |
IfPointcut.IfFalsePointcut.postRead(ResolvedType enclosingType)
|
void |
IfPointcut.IfTruePointcut.postRead(ResolvedType enclosingType)
|
void |
KindedPointcut.postRead(ResolvedType enclosingType)
|
void |
ReferencePointcut.postRead(ResolvedType enclosingType)
|
void |
WithincodePointcut.postRead(ResolvedType enclosingType)
|
void |
WithinPointcut.postRead(ResolvedType enclosingType)
|
void |
SignaturePattern.postRead(ResolvedType enclosingType)
|
void |
TypePatternList.postRead(ResolvedType enclosingType)
|
void |
DeclareAnnotation.setAspect(ResolvedType typeX)
|
void |
Declare.setDeclaringType(ResolvedType aType)
|
Constructors in org.aspectj.weaver.patterns with parameters of type ResolvedType | |
---|---|
ConcreteCflowPointcut.Slot(int formalIndex,
ResolvedType formalType,
int arrayIndex)
|
|
ConcreteCflowPointcut(ResolvedType aspect,
Member cflowField,
java.util.List slots,
boolean usesCounter)
|
|
FastMatchInfo(ResolvedType type,
Shadow.Kind kind,
World world)
|
|
PerThisOrTargetPointcutVisitor(boolean isTarget,
ResolvedType fromAspectType)
|
|
TypePatternQuestions.Question(TypePattern pattern,
ResolvedType type,
TypePattern.MatchKind kind)
|
Uses of ResolvedType in org.aspectj.weaver.reflect |
---|
Fields in org.aspectj.weaver.reflect declared as ResolvedType | |
---|---|
static ResolvedType[][] |
Java15AnnotationFinder.NO_PARAMETER_ANNOTATIONS
|
Methods in org.aspectj.weaver.reflect that return ResolvedType | |
---|---|
ResolvedType |
JavaLangTypeToResolvedTypeConverter.fromType(java.lang.reflect.Type aType)
|
ResolvedType[] |
JavaLangTypeToResolvedTypeConverter.fromTypes(java.lang.reflect.Type[] types)
|
ResolvedType[] |
Java15AnnotationFinder.getAnnotations(java.lang.Class forClass,
World inWorld)
|
ResolvedType[] |
Java15ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()
|
ResolvedType[] |
ReflectionBasedReferenceTypeDelegate.getAnnotationTypes()
|
ResolvedType[] |
ReflectionBasedResolvedMemberImpl.getAnnotationTypes()
|
ResolvedType[] |
Java15ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()
|
ResolvedType[] |
ReflectionBasedReferenceTypeDelegate.getDeclaredInterfaces()
|
ResolvedType |
Java15ReflectionBasedReferenceTypeDelegate.getGenericResolvedType()
Returns the generic type, regardless of the resolvedType we 'know about' |
ResolvedType |
ReflectionBasedReferenceTypeDelegate.getOuterClass()
|
ResolvedType[][] |
ReflectionBasedResolvedMemberImpl.getParameterAnnotationTypes()
|
ResolvedType[][] |
Java15AnnotationFinder.getParameterAnnotationTypes(java.lang.reflect.Member onMember)
|
ResolvedType[][] |
AnnotationFinder.getParameterAnnotationTypes(java.lang.reflect.Member onMember)
|
ResolvedType |
Java15ReflectionBasedReferenceTypeDelegate.getSuperclass()
|
ResolvedType |
ReflectionBasedReferenceTypeDelegate.getSuperclass()
|
ResolvedType |
ReflectionWorld.resolve(java.lang.Class aClass)
|
ResolvedType |
IReflectionWorld.resolve(java.lang.Class aClass)
|
static ResolvedType |
ReflectionWorld.resolve(World world,
java.lang.Class aClass)
|
static ResolvedType |
ReflectionBasedReferenceTypeDelegateFactory.resolveTypeInWorld(java.lang.Class aClass,
World aWorld)
|
Methods in org.aspectj.weaver.reflect with parameters of type ResolvedType | |
---|---|
static 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)
|
java.lang.Object |
Java15AnnotationFinder.getAnnotation(ResolvedType annotationType,
java.lang.Object onObject)
|
java.lang.Object |
AnnotationFinder.getAnnotation(ResolvedType annotationType,
java.lang.Object onObject)
|
java.lang.Object |
Java15AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType,
java.lang.Class aClass)
|
java.lang.Object |
AnnotationFinder.getAnnotationFromClass(ResolvedType annotationType,
java.lang.Class aClass)
|
java.lang.Object |
Java15AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType,
java.lang.reflect.Member aMember)
|
java.lang.Object |
AnnotationFinder.getAnnotationFromMember(ResolvedType annotationType,
java.lang.reflect.Member aMember)
|
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 ResolvedType | |
---|---|
ReflectionFastMatchInfo(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 ResolvedType | |
---|---|
ShadowMatch |
StandardPointcutExpression.matchesStaticInitialization(ResolvedType aType)
Determine whether or not this pointcut matches the static initialization of the given class. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |