typeClass = ClassUtils.forName(type.getName(), this.matchClass.getClassLoader());
/** * {@inheritDoc} */ public final String getTypeName() { return type.getName(); }
private String getKey(Pointcut p, ResolvedType a, String stackOrCounter) { StringBuffer sb = new StringBuffer(); sb.append(a.getName()); sb.append("::"); sb.append(p.toString()); sb.append("::"); sb.append(stackOrCounter); return sb.toString(); }
@Override public boolean isAssignableFrom(ResolvedType other) { raiseCantFindType(WeaverMessages.CANT_FIND_TYPE_ASSIGNABLE, other.getName()); return false; }
public Object getAnnotation(ResolvedType annotationType, Object onObject) { try { Class<? extends Annotation> annotationClass = (Class<? extends Annotation>) Class.forName(annotationType.getName(), false, getClassLoader()); if (onObject.getClass().isAnnotationPresent(annotationClass)) { return onObject.getClass().getAnnotation(annotationClass); } } catch (ClassNotFoundException ex) { // just return null } return null; }
public Object getAnnotationFromClass(ResolvedType annotationType, Class aClass) { try { Class<? extends Annotation> annotationClass = (Class<? extends Annotation>) Class.forName(annotationType.getName(), false, getClassLoader()); if (aClass.isAnnotationPresent(annotationClass)) { return aClass.getAnnotation(annotationClass); } } catch (ClassNotFoundException ex) { // just return null } return null; }
@Override public boolean isCoerceableFrom(ResolvedType other) { raiseCantFindType(WeaverMessages.CANT_FIND_TYPE_COERCEABLE, other.getName()); return false; }
@Override public boolean isAspectIncluded(ResolvedType aspectType) { if (!isXmlConfigured()) { return true; } return xmlConfiguration.specifiesInclusionOfAspect(aspectType.getName()); }
public Object getAnnotationFromMember(ResolvedType annotationType, Member aMember) { if (!(aMember instanceof AccessibleObject)) return null; AccessibleObject ao = (AccessibleObject) aMember; try { Class annotationClass = Class.forName(annotationType.getName(), false, getClassLoader()); if (ao.isAnnotationPresent(annotationClass)) { return ao.getAnnotation(annotationClass); } } catch (ClassNotFoundException ex) { // just return null } return null; }
public void setSuperClass(ResolvedType newSuperclass) { regenerateGenericSignatureAttribute = true; superclass = newSuperclass; // myType.addParent(typeX); // used for the attribute if (newSuperclass.getGenericType() != null) { newSuperclass = newSuperclass.getGenericType(); } myGen.setSuperclassName(newSuperclass.getName()); // used in the real // class data }
public void insertLoad(InstructionList il, InstructionFactory fact) { InstructionList loadInstructions = new InstructionList(); loadInstructions.append(fact.createInvoke(getType().getName(), "aspectOf", "()" + getType().getSignature(), Constants.INVOKESTATIC)); il.insert(loadInstructions); // throw new IllegalStateException(); // il.insert(createLoad(fact)); }
/** * Rule 2. Can't extend final types */ private boolean enforceDecpRule2_cantExtendFinalClass(BcelClassWeaver weaver, ISourceLocation transformerLoc, LazyClassGen targetType, ResolvedType newParent) { if (newParent.isFinal()) { error(weaver, "Cannot make type " + targetType.getName() + " extend final class " + newParent.getName(), targetType .getType().getSourceLocation(), new ISourceLocation[] { transformerLoc }); return false; } return true; }
private void verifyRuntimeRetention(ResolvedType rAnnotationType) { if (!(rAnnotationType.isAnnotationWithRuntimeRetention())) { IMessage m = MessageUtil.error(WeaverMessages.format(WeaverMessages.BINDING_NON_RUNTIME_RETENTION_ANNOTATION, rAnnotationType.getName()), getSourceLocation()); rAnnotationType.getWorld().getMessageHandler().handleMessage(m); } }
protected void verifyIsAnnotationType(ResolvedType type, IScope scope) { if (!type.isAnnotation()) { IMessage m = MessageUtil.error(WeaverMessages.format(WeaverMessages.REFERENCE_TO_NON_ANNOTATION_TYPE, type.getName()), getSourceLocation()); scope.getWorld().getMessageHandler().handleMessage(m); resolved = false; } }
public void weaveNormalTypeMungers(ResolvedType onType) { ContextToken tok = CompilationAndWeavingContext.enteringPhase(CompilationAndWeavingContext.PROCESSING_TYPE_MUNGERS, onType.getName()); if (onType.isRawType() || onType.isParameterizedType()) { onType = onType.getGenericType(); } for (ConcreteTypeMunger m : typeMungerList) { if (!m.isLateMunger() && m.matches(onType)) { onType.addInterTypeMunger(m, false); } } CompilationAndWeavingContext.leavingPhase(tok); }
public boolean match(ResolvedType typeX) { if (!child.matchesStatically(typeX)) { return false; } if (typeX.getWorld().getLint().typeNotExposedToWeaver.isEnabled() && !typeX.isExposedToWeaver()) { typeX.getWorld().getLint().typeNotExposedToWeaver.signal(typeX.getName(), getSourceLocation()); } return true; }
/** * For declare atType. */ public boolean matches(ResolvedType type) { if (!typePattern.matchesStatically(type)) { return false; } if (type.getWorld().getLint().typeNotExposedToWeaver.isEnabled() && !type.isExposedToWeaver()) { type.getWorld().getLint().typeNotExposedToWeaver.signal(type.getName(), getSourceLocation()); } return true; }
@Override protected boolean matchesExactly(ResolvedType type, ResolvedType annotatedType) { String targetTypeName = type.getName(); // System.err.println("match: " + targetTypeName + ", " + knownMatches); //Arrays.asList(importedPrefixes)); // Ensure the annotation pattern is resolved annotationPattern.resolve(type.getWorld()); return matchesExactlyByName(targetTypeName, type.isAnonymous(), type.isNested()) && matchesParameters(type, STATIC) && matchesBounds(type, STATIC) && annotationPattern.matches(annotatedType, type.temporaryAnnotationTypes).alwaysTrue(); }
private void generatePerCflowPushMethod(LazyClassGen classGen) { InstructionFactory factory = classGen.getFactory(); LazyMethodGen method = makeMethodGen(classGen, AjcMemberMaker.perCflowPush(aspectType)); flagAsSynthetic(method, true); classGen.addMethodGen(method); InstructionList il = method.getBody(); il.append(Utility.createGet(factory, AjcMemberMaker.perCflowField(aspectType))); il.append(factory.createNew(aspectType.getName())); il.append(InstructionConstants.DUP); il.append(factory.createInvoke(aspectType.getName(), "<init>", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL)); il.append(Utility.createInvoke(factory, Constants.INVOKEVIRTUAL, AjcMemberMaker.cflowStackPushInstance())); il.append(InstructionFactory.createReturn(Type.VOID)); }
public InstructionList createLoadInstructions(ResolvedType toType, InstructionFactory fact) { InstructionList il = new InstructionList(); Type jlClass = BcelWorld.makeBcelType(UnresolvedType.JL_CLASS); Type jlaAnnotation = BcelWorld.makeBcelType(UnresolvedType.ANNOTATION); il.append(target.createLoad(fact)); il.append(fact.createInvoke("java/lang/Object", "getClass", jlClass, new Type[] {}, Constants.INVOKEVIRTUAL)); il.append(fact.createConstant(new ObjectType(toType.getName()))); il.append(fact.createInvoke("java/lang/Class", "getAnnotation", jlaAnnotation, new Type[] { jlClass }, Constants.INVOKEVIRTUAL)); il.append(Utility.createConversion(fact, jlaAnnotation, BcelWorld.makeBcelType(toType))); return il; }