コード例 #1
0
 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);
 }
コード例 #2
0
  private static FuzzyBoolean inStar(
      final TypePattern[] pattern,
      ResolvableTypeList target,
      int pi,
      int ti,
      final int pLeft,
      int tLeft,
      int starsLeft,
      TypePattern.MatchKind kind,
      ResolvedType[][] parameterAnnotations) {
    // invariant: pLeft > 0, so we know we'll run out of stars and find a real char in pattern
    TypePattern patternChar = pattern[pi];
    while (patternChar == TypePattern.ELLIPSIS) {
      starsLeft--;
      patternChar = pattern[++pi];
    }
    while (true) {
      // invariant: if (tLeft > 0) then (ti < target.length)
      if (pLeft > tLeft) {
        return FuzzyBoolean.NO;
      }

      ResolvedType type = target.getResolved(ti);
      FuzzyBoolean ff = null;
      try {
        if (parameterAnnotations != null) {
          type.temporaryAnnotationTypes = parameterAnnotations[ti];
        }
        ff = patternChar.matches(type, kind);
      } finally {
        type.temporaryAnnotationTypes = null;
      }

      if (ff.maybeTrue()) {
        FuzzyBoolean xx =
            outOfStar(
                pattern,
                target,
                pi + 1,
                ti + 1,
                pLeft - 1,
                tLeft - 1,
                starsLeft,
                kind,
                parameterAnnotations);
        if (xx.maybeTrue()) {
          return ff.and(xx);
        }
      }
      ti++;
      tLeft--;
    }
  }
コード例 #3
0
 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);
   }
 }
コード例 #4
0
 private static FuzzyBoolean outOfStar(
     final TypePattern[] pattern,
     ResolvableTypeList target,
     int pi,
     int ti,
     int pLeft,
     int tLeft,
     final int starsLeft,
     TypePattern.MatchKind kind,
     ResolvedType[][] parameterAnnotations) {
   if (pLeft > tLeft) {
     return FuzzyBoolean.NO;
   }
   FuzzyBoolean finalReturn = FuzzyBoolean.YES;
   while (true) {
     // invariant: if (tLeft > 0) then (ti < target.length && pi < pattern.length)
     if (tLeft == 0) {
       return finalReturn;
     }
     if (pLeft == 0) {
       if (starsLeft > 0) {
         return finalReturn;
       } else {
         return FuzzyBoolean.NO;
       }
     }
     if (pattern[pi] == TypePattern.ELLIPSIS) {
       return inStar(
           pattern, target, pi + 1, ti, pLeft, tLeft, starsLeft - 1, kind, parameterAnnotations);
     }
     FuzzyBoolean ret = null;
     ResolvedType type = target.getResolved(ti);
     try {
       if (parameterAnnotations != null) {
         type.temporaryAnnotationTypes = parameterAnnotations[ti];
       }
       ret = pattern[pi].matches(type, kind);
     } finally {
       type.temporaryAnnotationTypes = null;
     }
     if (ret == FuzzyBoolean.NO) {
       return ret;
     }
     if (ret == FuzzyBoolean.MAYBE) {
       finalReturn = ret;
     }
     pi++;
     ti++;
     pLeft--;
     tLeft--;
   }
 }
コード例 #5
0
 public List<UnresolvedType> getExactTypes() {
   List<UnresolvedType> ret = new ArrayList<UnresolvedType>();
   for (int i = 0; i < typePatterns.length; i++) {
     UnresolvedType t = typePatterns[i].getExactType();
     if (!ResolvedType.isMissing(t)) {
       ret.add(t);
     }
   }
   return ret;
 }
コード例 #6
0
  public FuzzyBoolean matches(
      ResolvableTypeList types, TypePattern.MatchKind kind, ResolvedType[][] parameterAnnotations) {
    int nameLength = types.length;
    int patternLength = typePatterns.length;

    int nameIndex = 0;
    int patternIndex = 0;

    if (ellipsisCount == 0) {
      if (nameLength != patternLength) {
        return FuzzyBoolean.NO;
      }
      FuzzyBoolean finalReturn = FuzzyBoolean.YES;
      while (patternIndex < patternLength) {
        ResolvedType t = types.getResolved(nameIndex);
        FuzzyBoolean ret = null;
        try {
          if (parameterAnnotations != null) {
            t.temporaryAnnotationTypes = parameterAnnotations[nameIndex];
          }
          ret = typePatterns[patternIndex].matches(t, kind);
        } finally {
          t.temporaryAnnotationTypes = null;
        }
        patternIndex++;
        nameIndex++;
        if (ret == FuzzyBoolean.NO) {
          return ret;
        }
        if (ret == FuzzyBoolean.MAYBE) {
          finalReturn = ret;
        }
      }
      return finalReturn;
    } else if (ellipsisCount == 1) {
      if (nameLength < patternLength - 1) {
        return FuzzyBoolean.NO;
      }
      FuzzyBoolean finalReturn = FuzzyBoolean.YES;
      while (patternIndex < patternLength) {
        TypePattern p = typePatterns[patternIndex++];
        if (p == TypePattern.ELLIPSIS) {
          nameIndex = nameLength - (patternLength - patternIndex);
        } else {
          ResolvedType t = types.getResolved(nameIndex);
          FuzzyBoolean ret = null;
          try {
            if (parameterAnnotations != null) {
              t.temporaryAnnotationTypes = parameterAnnotations[nameIndex];
            }
            ret = p.matches(t, kind);
          } finally {
            t.temporaryAnnotationTypes = null;
          }
          nameIndex++;
          if (ret == FuzzyBoolean.NO) {
            return ret;
          }
          if (ret == FuzzyBoolean.MAYBE) {
            finalReturn = ret;
          }
        }
      }
      return finalReturn;
    } else {
      // System.err.print("match(" + arguments + ", " + types + ") -> ");
      FuzzyBoolean b =
          outOfStar(
              typePatterns,
              types,
              0,
              0,
              patternLength - ellipsisCount,
              nameLength,
              ellipsisCount,
              kind,
              parameterAnnotations);
      // System.err.println(b);
      return b;
    }
  }
コード例 #7
0
 private String stringify(ResolvedType resolvedAnnotationType) {
   return "@" + resolvedAnnotationType.getSimpleName();
 }