Package org.aspectj.weaver

Examples of org.aspectj.weaver.World


    }

    public void visit(HasAnnotation hasAnnotation) {
      ReflectionVar v = (ReflectionVar) hasAnnotation.getVar();
      Object value = v.getBindingAtJoinPoint(thisObject, targetObject, args);
      World world = v.getType().getWorld();
      ResolvedType actualVarType = world.resolve(value.getClass().getName());
      ResolvedType requiredAnnotationType = hasAnnotation.getAnnotationType().resolve(world);
      matches = actualVarType.hasAnnotation(requiredAnnotationType);
    }
View Full Code Here


    }

    Member cflowStackField = new ResolvedMemberImpl(Member.FIELD, inAspect, Modifier.STATIC | Modifier.PUBLIC | Modifier.FINAL,
        UnresolvedType.forName(NameMangler.CFLOW_STACK_TYPE), NameMangler.PERCFLOW_FIELD_NAME, UnresolvedType.NONE);

    World world = inAspect.getWorld();

    CrosscuttingMembers xcut = inAspect.crosscuttingMembers;

    Collection previousCflowEntries = xcut.getCflowEntries();
    Pointcut concreteEntry = entry.concretize(inAspect, inAspect, 0, null); // IntMap
View Full Code Here

      // No annotation found
      return false;
    }

    Method annotatedMethod = struct.method;
    World world = struct.enclosingType.getWorld();
    NameValuePair declareMixinPatternNameValuePair = getAnnotationElement(declareMixinAnnotation, VALUE);

    // declareMixinPattern could be of the form "Bar*" or "A || B" or "Foo+"
    String declareMixinPattern = declareMixinPatternNameValuePair.getValue().stringifyValue();
    TypePattern targetTypePattern = parseTypePattern(declareMixinPattern, struct);
View Full Code Here

  private final static String declareAtPrefix = "ajc$declare_at";

  private boolean hasField(ResolvedType type) {
    // TODO what about ITDs
    World world = type.getWorld();
    for (Iterator iter = type.getFields(); iter.hasNext();) {
      Member field = (Member) iter.next();
      if (field.getName().startsWith(declareAtPrefix)) {
        continue;
      }
View Full Code Here

    return false;
  }

  private boolean hasMethod(ResolvedType type) {
    // TODO what about ITDs
    World world = type.getWorld();
    for (Iterator iter = type.getMethods(true, true); iter.hasNext();) {
      Member method = (Member) iter.next();
      if (method.getName().startsWith(declareAtPrefix)) {
        continue;
      }
View Full Code Here

      }
    }
    entryBindings.copyContext(bindings);
    // System.out.println(this + " bindings: " + entryBindings);

    World world = inAspect.getWorld();

    Pointcut concreteEntry;

    ResolvedType concreteAspect = bindings.getConcreteAspect();

    CrosscuttingMembers xcut = concreteAspect.crosscuttingMembers;
    Collection previousCflowEntries = xcut.getCflowEntries();

    entryBindings.pushEnclosingDefinition(CFLOW_MARKER);
    // This block concretizes the pointcut within the cflow pointcut
    try {
      concreteEntry = entry.concretize(inAspect, declaringType, entryBindings);
    } finally {
      entryBindings.popEnclosingDefinitition();
    }

    List innerCflowEntries = new ArrayList(xcut.getCflowEntries());
    innerCflowEntries.removeAll(previousCflowEntries);

    // Four routes of interest through this code (did I hear someone say
    // refactor??)
    // 1) no state in the cflow - we can use a counter *and* we have seen
    // this pointcut
    // before - so use the same counter as before.
    // 2) no state in the cflow - we can use a counter, but this is the
    // first time
    // we have seen this pointcut, so build the infrastructure.
    // 3) state in the cflow - we need to use a stack *and* we have seen
    // this pointcut
    // before - so share the stack.
    // 4) state in the cflow - we need to use a stack, but this is the first
    // time
    // we have seen this pointcut, so build the infrastructure.

    if (freeVars == null || freeVars.length == 0) { // No state, so don't
      // use a stack, use a
      // counter.
      ResolvedMember localCflowField = null;

      Object field = getCflowfield(xcut, concreteEntry, concreteAspect, "counter");

      // Check if we have already got a counter for this cflow pointcut
      if (field != null) {
        localCflowField = (ResolvedMember) field; // Use the one we
        // already have

      } else {

        // Create a counter field in the aspect
        localCflowField = new ResolvedMemberImpl(Member.FIELD, concreteAspect, Modifier.STATIC | Modifier.PUBLIC
            | Modifier.FINAL, NameMangler.cflowCounter(xcut), UnresolvedType.forName(NameMangler.CFLOW_COUNTER_TYPE)
            .getSignature());

        // Create type munger to add field to the aspect
        concreteAspect.crosscuttingMembers.addTypeMunger(world.getWeavingSupport().makeCflowCounterFieldAdder(
            localCflowField));

        // Create shadow munger to push stuff onto the stack
        concreteAspect.crosscuttingMembers.addConcreteShadowMunger(Advice.makeCflowEntry(world, concreteEntry, isBelow,
            localCflowField, freeVars == null ? 0 : freeVars.length, innerCflowEntries, inAspect));

        putCflowfield(xcut, concreteEntry, concreteAspect, localCflowField, "counter"); // Remember
        // it
      }

      Pointcut ret = new ConcreteCflowPointcut(concreteAspect, localCflowField, null, true);
      ret.copyLocationFrom(this);
      return ret;
    } else {

      List slots = new ArrayList();

      for (int i = 0, len = freeVars.length; i < len; i++) {
        int freeVar = freeVars[i];

        // we don't need to keep state that isn't actually exposed to
        // advice
        // ??? this means that we will store some state that we won't
        // actually use, optimize this later
        if (!bindings.hasKey(freeVar)) {
          continue;
        }

        int formalIndex = bindings.get(freeVar);

        // We need to look in the right place for the type of the
        // formal. Suppose the advice looks like this:
        // before(String s): somePointcut(*,s)
        // where the first argument in somePointcut is of type Number
        // for free variable 0 we want to ask the pointcut for the type
        // of its first argument, if we only
        // ask the advice for the type of its first argument then we'll
        // get the wrong type (pr86903)

        ResolvedPointcutDefinition enclosingDef = bindings.peekEnclosingDefinition();
        ResolvedType formalType = null;

        // Is there a useful enclosing pointcut?
        if (enclosingDef != null && enclosingDef.getParameterTypes().length > 0) {
          formalType = enclosingDef.getParameterTypes()[freeVar].resolve(world);
        } else {
          formalType = bindings.getAdviceSignature().getParameterTypes()[formalIndex].resolve(world);
        }

        ConcreteCflowPointcut.Slot slot = new ConcreteCflowPointcut.Slot(formalIndex, formalType, i);
        slots.add(slot);
      }
      ResolvedMember localCflowField = null;
      Object field = getCflowfield(xcut, concreteEntry, concreteAspect, "stack");
      if (field != null) {
        localCflowField = (ResolvedMember) field;
      } else {

        localCflowField = new ResolvedMemberImpl(Member.FIELD, concreteAspect, Modifier.STATIC | Modifier.PUBLIC
            | Modifier.FINAL, NameMangler.cflowStack(xcut), UnresolvedType.forName(NameMangler.CFLOW_STACK_TYPE)
            .getSignature());
        // System.out.println("adding field to: " + inAspect + " field "
        // + cflowField);

        // add field and initializer to inAspect
        // XXX and then that info above needs to be mapped down here to
        // help with
        // XXX getting the exposed state right
        concreteAspect.crosscuttingMembers.addConcreteShadowMunger(Advice.makeCflowEntry(world, concreteEntry, isBelow,
            localCflowField, freeVars.length, innerCflowEntries, inAspect));

        concreteAspect.crosscuttingMembers.addTypeMunger(world.getWeavingSupport()
            .makeCflowStackFieldAdder(localCflowField));
        putCflowfield(xcut, concreteEntry, concreteAspect, localCflowField, "stack");
      }
      Pointcut ret = new ConcreteCflowPointcut(concreteAspect, localCflowField, slots, false);
      ret.copyLocationFrom(this);
View Full Code Here

        if (superclassName == null) {
          superclassName = javaClass.getSuperclassName();
        }
        superclassSignature = getResolvedTypeX().getWorld().resolve(UnresolvedType.forName(superclassName)).getSignature();
      }
      World world = getResolvedTypeX().getWorld();
      supertype = world.resolve(UnresolvedType.forSignature(superclassSignature));
      superTypeReference = new WeakReference<ResolvedType>(supertype);
    }
    return supertype;
  }
View Full Code Here

        AnnotationGen annos[] = javaClass.getAnnotations();
        if (annos == null || annos.length == 0) {
          annotationTypes = ResolvedType.NONE;
          annotations = AnnotationAJ.EMPTY_ARRAY;
        } else {
          World w = getResolvedTypeX().getWorld();
          annotationTypes = new ResolvedType[annos.length];
          annotations = new AnnotationAJ[annos.length];
          for (int i = 0; i < annos.length; i++) {
            AnnotationGen annotation = annos[i];
            String typeSignature = annotation.getTypeSignature();
            ResolvedType rType = w.resolve(UnresolvedType.forSignature(typeSignature));
            if (rType == null) {
              throw new RuntimeException("Whilst unpacking annotations on '" + getResolvedTypeX().getName()
                  + "', failed to resolve type '" + typeSignature + "'");
            }
            annotationTypes[i] = rType;
View Full Code Here

    if (typeToCheck.getWorld().forDEBUG_bridgingCode) {
      System.err.println("  Bridging:seriously considering this might be getting overridden '"
          + methodThatMightBeGettingOverridden + "'");
    }

    World w = typeToCheck.getWorld();

    // Look at erasures of parameters (List<String> erased is List)
    boolean sameParams = true;
    for (int p = 0, max = methodThatMightBeGettingOverridden.getParameterTypes().length; p < max; p++) {
View Full Code Here

  private boolean couldMatch(BcelObjectType bcelObjectType, Pointcut pointcut) {
    return !bcelObjectType.isInterface();
  }

  private boolean mungeNewMemberType(BcelClassWeaver classWeaver, NewMemberClassTypeMunger munger) {
    World world = classWeaver.getWorld();
    ResolvedType onType = world.resolve(munger.getTargetType());
    if (onType.isRawType()) {
      onType = onType.getGenericType();
    }
    return onType.equals(classWeaver.getLazyClassGen().getType());
  }
View Full Code Here

TOP

Related Classes of org.aspectj.weaver.World

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.