private AnnotatedTypeMirror postFixDouble(AnnotatedTypeMirror anno, boolean increment) { List<Double> values = getDoubleValues(anno.getAnnotation(DoubleVal.class)); List<? extends Number> castedValues = NumberUtils.castNumbers(anno.getUnderlyingType(), values); List<Double> results = new ArrayList<>(); for (Number value : castedValues) { NumberMath<?> number = NumberMath.getNumberMath(value); if (increment) { results.add(number.minus(1).doubleValue()); } else { results.add(number.plus(1).doubleValue()); } } anno.replaceAnnotation(createDoubleValAnnotation(results)); return anno; }
private void handleInitalizers( List<? extends ExpressionTree> initializers, AnnotatedArrayType type) { List<Integer> array = new ArrayList<>(); array.add(initializers.size()); type.replaceAnnotation(createArrayLenAnnotation(array)); boolean singleDem = type.getComponentType().getKind() != TypeKind.ARRAY; if (singleDem) { return; } List<List<Integer>> summarylengths = new ArrayList<>(); for (ExpressionTree init : initializers) { AnnotatedArrayType subArrayType = (AnnotatedArrayType) getAnnotatedType(init); AnnotatedTypeMirror componentType = subArrayType; int count = 0; while (componentType.getKind() == TypeKind.ARRAY) { AnnotationMirror arrayLen = componentType.getAnnotation(ArrayLen.class); List<Integer> currentLengths; if (arrayLen != null) { currentLengths = getArrayLength(arrayLen); } else { currentLengths = (new ArrayList<Integer>()); } if (count == summarylengths.size()) { summarylengths.add(new ArrayList<Integer>()); } summarylengths.get(count).addAll(currentLengths); count++; componentType = ((AnnotatedArrayType) componentType).getComponentType(); } } AnnotatedTypeMirror componentType = type.getComponentType(); int i = 0; while (componentType.getKind() == TypeKind.ARRAY) { componentType.addAnnotation(createArrayLenAnnotation(summarylengths.get(i))); componentType = ((AnnotatedArrayType) componentType).getComponentType(); i++; } }
@Override public Void visitMemberSelect(MemberSelectTree tree, AnnotatedTypeMirror type) { if (TreeUtils.isFieldAccess(tree) && isUnderlyingTypeAValue(type)) { VariableElement elem = (VariableElement) InternalUtils.symbol(tree); Object value = elem.getConstantValue(); if (value != null) { // compile time constant type.replaceAnnotation( resultAnnotationHandler( type.getUnderlyingType(), Collections.singletonList(value), tree)); return null; } if (ElementUtils.isStatic(elem) && ElementUtils.isFinal(elem)) { Element e = InternalUtils.symbol(tree.getExpression()); if (e != null) { String classname = ElementUtils.getQualifiedClassName(e).toString(); String fieldName = tree.getIdentifier().toString(); value = evalutator.evaluateStaticFieldAccess(classname, fieldName, tree); if (value != null) type.replaceAnnotation( resultAnnotationHandler( type.getUnderlyingType(), Collections.singletonList(value), tree)); return null; } } if (tree.getIdentifier().toString().equals("length")) { AnnotatedTypeMirror receiverType = getAnnotatedType(tree.getExpression()); if (receiverType.getKind() == TypeKind.ARRAY) { AnnotationMirror arrayAnno = receiverType.getAnnotation(ArrayLen.class); if (arrayAnno != null) { // array.length, where array : @ArrayLen(x) List<Integer> lengths = ValueAnnotatedTypeFactory.getArrayLength(arrayAnno); type.replaceAnnotation(createNumberAnnotationMirror(new ArrayList<Number>(lengths))); return null; } } } } return null; }