public int compareTo(Object other) { IfaceInitList o = (IfaceInitList) other; if (onType.isAssignableFrom(o.onType)) { return +1; } else if (o.onType.isAssignableFrom(onType)) { return -1; } else { return 0; } }
private boolean isASubtypeOf(UnresolvedType candidateSuperType, UnresolvedType candidateSubType) { ResolvedType superType = (ResolvedType) candidateSuperType; ResolvedType subType = (ResolvedType) candidateSubType; return superType.isAssignableFrom(subType); }
public boolean needsNoConversionFrom(ResolvedType o) { return isAssignableFrom(o); }
/** * @return true if assignable to java.lang.Exception */ public boolean isException() { return (world.getCoreType(UnresolvedType.JL_EXCEPTION).isAssignableFrom(this)); }
public int compareByPrecedenceAndHierarchy(ResolvedType firstAspect, ResolvedType secondAspect) { if (firstAspect.equals(secondAspect)) { return 0; } int ret = compareByPrecedence(firstAspect, secondAspect); if (ret != 0) { return ret; } if (firstAspect.isAssignableFrom(secondAspect)) { return -1; } else if (secondAspect.isAssignableFrom(firstAspect)) { return +1; } return 0; }
/** * Build a list containing every type between subtype and supertype, inclusively. */ private static void accumulateTypesInBetween(ResolvedType subType, ResolvedType superType, List<ResolvedType> types) { types.add(subType); if (subType == superType) { return; } else { for (Iterator<ResolvedType> iter = subType.getDirectSupertypes(); iter.hasNext();) { ResolvedType parent = iter.next(); if (superType.isAssignableFrom(parent)) { accumulateTypesInBetween(parent, superType, types); } } } }
/** * Build a list containing every type between subtype and supertype, inclusively. */ private void accumulateTypesInBetween(ResolvedType subType, ResolvedType superType, List<ResolvedType> types) { types.add(subType); if (subType == superType) { return; } else { for (Iterator<ResolvedType> iter = subType.getDirectSupertypes(); iter.hasNext();) { ResolvedType parent = iter.next(); if (superType.isAssignableFrom(parent, true)) { accumulateTypesInBetween(parent, superType, types); } } } }
public boolean isTopmostImplementor(ResolvedType interfaceType) { boolean b = true; if (isInterface()) { b = false; } else if (!interfaceType.isAssignableFrom(this, true)) { b = false; } else { ResolvedType superclass = this.getSuperclass(); if (superclass.isMissing()) { b = true; // we don't know anything about supertype, and it can't be exposed to weaver } else if (interfaceType.isAssignableFrom(superclass, true)) { // check that I'm truly the topmost implementor b = false; } } // System.out.println("is " + getName() + " topmostimplementor of " + interfaceType + "? " + b); return b; }
/** * @return true if it is an exception and it is a checked one, false otherwise. */ public boolean isCheckedException() { if (!isException()) { return false; } if (world.getCoreType(UnresolvedType.RUNTIME_EXCEPTION).isAssignableFrom(this)) { return false; } return true; }
private static boolean isSerializableAspect(ResolvedType aspectType) { return UnresolvedType.SERIALIZABLE.resolve(aspectType.getWorld()).isAssignableFrom(aspectType); }
public static boolean isVisible(int modifiers, ResolvedType targetType, ResolvedType fromType) { // System.err.println("mod: " + modifiers + ", " + targetType + " and " // + fromType); if (Modifier.isPublic(modifiers)) { return true; } else if (Modifier.isPrivate(modifiers)) { return targetType.getOutermostType().equals(fromType.getOutermostType()); } else if (Modifier.isProtected(modifiers)) { return samePackage(targetType, fromType) || targetType.isAssignableFrom(fromType); } else { // package-visible return samePackage(targetType, fromType); } }
public int compareTo(Object other) { ConcreteTypeMunger o = (ConcreteTypeMunger) other; ResolvedType otherAspect = o.aspectType; if (aspectType.equals(otherAspect)) { return getSignature().getStart() < o.getSignature().getStart() ? -1 : +1; } else if (aspectType.isAssignableFrom(o.aspectType)) { return +1; } else if (o.aspectType.isAssignableFrom(aspectType)) { return -1; } else { return 0; } }
public ResolvedType getTopmostImplementor(ResolvedType interfaceType) { if (isInterface()) { return null; } if (!interfaceType.isAssignableFrom(this)) { return null; } // Check if my super class is an implementor? ResolvedType higherType = this.getSuperclass().getTopmostImplementor(interfaceType); if (higherType != null) { return higherType; } return this; }
public static ResolvedMember perObjectField(UnresolvedType declaringType, ResolvedType aspectType) { int modifiers = Modifier.PRIVATE; if (!UnresolvedType.SERIALIZABLE.resolve(aspectType.getWorld()).isAssignableFrom(aspectType)) { modifiers |= Modifier.TRANSIENT; } return new ResolvedMemberImpl(Member.FIELD, declaringType, modifiers, aspectType, NameMangler.perObjectInterfaceField(aspectType), UnresolvedType.NONE); }
private boolean isDeclaredException(ResolvedType resolvedTypeX, Member member) { ResolvedType[] excs = getIWorld().resolve(member.getExceptions(getIWorld())); for (int i = 0, len = excs.length; i < len; i++) { if (excs[i].isAssignableFrom(resolvedTypeX)) { return true; } } return false; }
public void visit(Instanceof instanceofTest) { ReflectionVar v = (ReflectionVar) instanceofTest.getVar(); Object value = v.getBindingAtJoinPoint(thisObject, targetObject, args); World world = v.getType().getWorld(); ResolvedType desiredType = instanceofTest.getType().resolve(world); if (value == null) { matches = false; } else { ResolvedType actualType = world.resolve(value.getClass().getName()); matches = desiredType.isAssignableFrom(actualType); } }
public void visit(Instanceof i) { ReflectionVar v = (ReflectionVar) i.getVar(); Object value = v.getBindingAtJoinPoint(thisObject, targetObject, args); World world = v.getType().getWorld(); ResolvedType desiredType = i.getType().resolve(world); ResolvedType actualType = world.resolve(value.getClass().getName()); matches = desiredType.isAssignableFrom(actualType); }
public boolean alwaysMatches(ResolvedType aCandidateType) { if (isExtends()) { // aCandidateType must be a subtype of upperBound return ((ReferenceType) getUpperBound()).isAssignableFrom(aCandidateType); } else if (isSuper()) { // aCandidateType must be a supertype of lowerBound return aCandidateType.isAssignableFrom((ReferenceType) getLowerBound()); } else { return true; // straight '?' } }
public static Test makeInstanceof(Var v, ResolvedType ty) { if (ty.equals(ResolvedType.OBJECT)) return Literal.TRUE; Test e; if (ty.isAssignableFrom(v.getType())) e = Literal.TRUE; else if (! ty.isCoerceableFrom(v.getType())) e = Literal.FALSE; else e = new Instanceof(v, ty); return e; }
public final boolean isAssignableFrom(ResolvedType o) { if (!o.isArray()) return false; if (o.getComponentType().isPrimitiveType()) { return o.equals(this); } else { return getComponentType().resolve(world).isAssignableFrom(o.getComponentType().resolve(world)); } }