/** * 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; }
List<CtExpression<?>> elements = ((CtNewArray) expression).getElements(); for (CtExpression expInArray : elements) { ((CtNewArray) ctExpression).addElement(expInArray); ((CtNewArray) ctExpression).addElement(expression); newArray.setType(ctExpression.getType()); newArray.setParent(this); newArray.addElement(ctExpression); newArray.addElement(expression); elementValues.put(elementName, newArray);
@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); } } }
CtNewArray<Object> arr = factory.Core().createNewArray().setType(factory.Type().objectType()); for (CtExpression expr : (CtExpression[]) value) { arr.addElement(expr); if (v == null || v instanceof String || v instanceof Number || v instanceof Boolean || v instanceof Character) { arr.addElement(factory.Code().createLiteral(v)); } else { throw new SpoonException("Parameter value item class: " + v.getClass().getName() + " cannot be converted to class is: " + valueClass.getName());
((CtNewArray) res).addElement(convertValueToExpression(o)); res.setType(getFactory().Type().createArrayReference(getFactory().Type().createReference(values.toArray()[0].getClass()))); for (Object o : values) { ((CtNewArray) res).addElement(convertValueToExpression(o));
@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; }
@Override public <T> void visitCtNewArray(CtNewArray<T> newArray) { if (this.jdtTreeBuilder.context.isArgument(newArray)) { newArray.addDimensionExpression((CtExpression<Integer>) child); return; } else if (child instanceof CtExpression) { newArray.addElement((CtExpression<?>) child); return; } }
/** * 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; }
arrname.addElement(expr); arrnvalues.addElement(expr);
arrnames.addElement(expr); arrnvalues.addElement(expr);