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;
}
