/** * Creates a one-dimension array that must only contain literals. */ @SuppressWarnings("unchecked") public <T> CtNewArray<T[]> createLiteralArray(T[] value) { if (!value.getClass().isArray()) { throw new RuntimeException("value is not an array"); } if (value.getClass().getComponentType().isArray()) { throw new RuntimeException("can only create one-dimension arrays"); } final CtTypeReference<T> componentTypeRef = factory.Type().createReference((Class<T>) value.getClass().getComponentType()); final CtArrayTypeReference<T[]> arrayReference = factory.Type().createArrayReference(componentTypeRef); CtNewArray<T[]> array = factory.Core().<T[]>createNewArray().setType(arrayReference); for (T e : value) { CtLiteral<T> l = factory.Core().createLiteral(); l.setValue(e); array.addElement(l); } return array; }
public <T> void visitCtNewArray(final spoon.reflect.code.CtNewArray<T> newArray) { spoon.reflect.code.CtNewArray<T> aCtNewArray = newArray.getFactory().Core().createNewArray(); this.builder.copy(newArray, aCtNewArray); aCtNewArray.setAnnotations(this.cloneHelper.clone(newArray.getAnnotations())); aCtNewArray.setType(this.cloneHelper.clone(newArray.getType())); aCtNewArray.setTypeCasts(this.cloneHelper.clone(newArray.getTypeCasts())); aCtNewArray.setElements(this.cloneHelper.clone(newArray.getElements())); aCtNewArray.setDimensionExpressions(this.cloneHelper.clone(newArray.getDimensionExpressions())); aCtNewArray.setComments(this.cloneHelper.clone(newArray.getComments())); this.cloneHelper.tailor(newArray, aCtNewArray); this.other = aCtNewArray; }
@Override public <T> void visitCtNewArray(CtNewArray<T> newArray) { if (childJDT instanceof TypeReference && child instanceof CtTypeAccess) { final ArrayAllocationExpression arrayAlloc = (ArrayAllocationExpression) jdtTreeBuilder.getContextBuilder().stack.peek().node; newArray.setType((CtArrayTypeReference) jdtTreeBuilder.getFactory().Type().createArrayReference(((CtTypeAccess) child).getAccessedType(), arrayAlloc.dimensions.length)); } else if (child instanceof CtExpression) { if (isContainedInDimensionExpression()) { newArray.addDimensionExpression((CtExpression<Integer>) child); } else if (child instanceof CtNewArray && childJDT instanceof ArrayInitializer && jdtTreeBuilder.getContextBuilder().stack.peek().node instanceof ArrayAllocationExpression) { newArray.setElements(((CtNewArray) child).getElements()); } else { newArray.addElement((CtExpression) child); } } }
Class<?> itemClass = value.getClass().getComponentType(); if (CtExpression.class.isAssignableFrom(itemClass)) { CtNewArray<Object> arr = factory.Core().createNewArray().setType(factory.Type().objectType()); for (CtExpression expr : (CtExpression[]) value) { arr.addElement(expr); CtNewArray<?> arr = factory.Core().createNewArray().setType(factory.Type().createArrayReference(itemClass.getName())); for (Object v : (Object[]) value) { if (v == null || v instanceof String || v instanceof Number || v instanceof Boolean || v instanceof Character) {
newArray.setType(ctExpression.getType()); newArray.setParent(this); newArray.addElement(ctExpression);
@Override public <T extends CtExpression> T getWrappedValue(String key) { CtExpression ctExpression = this.getValue(key); CtTypeReference typeReference = this.getAnnotationType(); CtType type = typeReference.getTypeDeclaration(); if (type != null) { CtMethod method = type.getMethod(key); if (method != null) { CtTypeReference returnType = method.getType(); if (returnType instanceof CtArrayTypeReference && !(ctExpression instanceof CtNewArray)) { CtNewArray newArray = getFactory().Core().createNewArray(); CtArrayTypeReference typeReference2 = this.getFactory().createArrayTypeReference(); typeReference2.setComponentType(ctExpression.getType().clone()); newArray.setType(typeReference2); newArray.addElement(ctExpression.clone()); return (T) newArray; } } } return (T) ctExpression; }
/** * Creates a one-dimension array that must only contain literals. */ @SuppressWarnings("unchecked") public <T> CtNewArray<T[]> createLiteralArray(T[] value) { if (!value.getClass().isArray()) { throw new RuntimeException("value is not an array"); } if (value.getClass().getComponentType().isArray()) { throw new RuntimeException("can only create one-dimension arrays"); } final CtTypeReference<T> componentTypeRef = factory.Type().createReference((Class<T>) value.getClass().getComponentType()); final CtArrayTypeReference<T[]> arrayReference = factory.Type().createArrayReference(componentTypeRef); CtNewArray<T[]> array = factory.Core().<T[]>createNewArray().setType(arrayReference); for (T e : value) { CtLiteral<T> l = factory.Core().createLiteral(); l.setValue(e); array.addElement(l); } return array; }
private static CtExpression generateArray(CtTypeReference type) { CtArrayTypeReference arrayType = (CtArrayTypeReference) type; CtTypeReference typeComponent = arrayType.getComponentType(); CtNewArray<?> newArray = type.getFactory().createNewArray(); final int size = RandomHelper.getRandom().nextInt(MAX_ARRAY_SIZE); newArray.setType(arrayType); if (size == 0) { newArray.setDimensionExpressions(Collections.singletonList(type.getFactory().createLiteral(size))); } else if (ValueCreatorHelper.canGenerateAValueForType(typeComponent)) { IntStream.range(0, size) .mapToObj(i -> generateRandomValue(typeComponent, 0)) .forEach(newArray::addElement); } return newArray; }
@Override public boolean visit(ArrayAllocationExpression arrayAllocationExpression, BlockScope scope) { CtNewArray<Object> array = factory.Core().createNewArray(); array.setType(references.getTypeReference(arrayAllocationExpression.resolvedType)); context.enter(array, arrayAllocationExpression); context.pushArgument(array); if (arrayAllocationExpression.dimensions != null) { for (Expression e : arrayAllocationExpression.dimensions) { if (e != null) { e.traverse(this, scope); } } } context.popArgument(array); if (arrayAllocationExpression.initializer != null && arrayAllocationExpression.initializer.expressions != null) { for (Expression e : arrayAllocationExpression.initializer.expressions) { e.traverse(this, scope); } } return false; }