ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String ret = "scala.collection.mutable.Buffer"; if (!parameterizedType.getArgs().isEmpty()) ret += "[" + toScalaType(parameterizedType.getArg(0), convertTypeParamsToObject) + "]"; return wrapInOptionIfNullable(nullable, ret); } else if (kind == ClassKind.SET){ ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String ret = "scala.collection.mutable.Set"; if (!parameterizedType.getArgs().isEmpty()) ret += "[" + toScalaType(parameterizedType.getArg(0), convertTypeParamsToObject) + "]"; return wrapInOptionIfNullable(nullable, ret); } else if (kind == ClassKind.MAP){ ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String ret = "scala.collection.mutable.Map"; if (!parameterizedType.getArgs().isEmpty()) ret += "[" + toScalaType(parameterizedType.getArg(0), convertTypeParamsToObject) + ", " + toScalaType(parameterizedType.getArg(1), convertTypeParamsToObject) + "]"; return wrapInOptionIfNullable(nullable, ret); } else if (kind == ClassKind.HANDLER) { ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; return "Handler[" + toScalaType(parameterizedType.getArg(0), convertTypeParamsToObject) + "]"; } else if (kind == ClassKind.FUNCTION) { ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String type1 = toScalaType(parameterizedType.getArg(0), convertTypeParamsToObject); String type2 = toScalaType(parameterizedType.getArg(1), convertTypeParamsToObject); String ret; if (type1.equals("Unit")) { ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String ret = "AsyncResult";
private MethodInfo genFutureMethod(MethodInfo method) { String futMethodName = genFutureMethodName(method); List<ParamInfo> futParams = new ArrayList<>(); int count = 0; int size = method.getParams().size() - 1; while (count < size) { ParamInfo param = method.getParam(count); /* Transform ReadStream -> Flowable */ futParams.add(param); count = count + 1; } ParamInfo futParam = method.getParam(size); TypeInfo futType = ((ParameterizedTypeInfo) ((ParameterizedTypeInfo) futParam.getType()).getArg(0)).getArg(0); TypeInfo futUnresolvedType = ((ParameterizedTypeInfo) ((ParameterizedTypeInfo) futParam.getUnresolvedType()).getArg(0)).getArg(0); TypeInfo futReturnType; if (futUnresolvedType.getKind() == VOID) { futReturnType = io.vertx.codegen.type.TypeReflectionFactory.create(io.reactivex.Completable.class); } else if (futUnresolvedType.isNullable()) { futReturnType = new io.vertx.codegen.type.ParameterizedTypeInfo(io.vertx.codegen.type.TypeReflectionFactory.create(io.reactivex.Maybe.class).getRaw(), false, Collections.singletonList(futType)); } else { futReturnType = new io.vertx.codegen.type.ParameterizedTypeInfo(io.vertx.codegen.type.TypeReflectionFactory.create(io.reactivex.Single.class).getRaw(), false, Collections.singletonList(futType)); } return method.copy().setName(futMethodName).setReturnType(futReturnType).setParams(futParams); }
protected final String genTypeName(TypeInfo type) { if (type.isParameterized()) { ParameterizedTypeInfo pt = (ParameterizedTypeInfo) type; return genTypeName(pt.getRaw()) + pt.getArgs().stream().map(this::genTypeName).collect(Collectors.joining(", ", "<", ">")); } else if (type.getKind() == ClassKind.API) { return type.translateName(id); } else { return type.getSimpleName(); } }
public static String convertArgListToString(TypeInfo type, boolean convert, BiFunction<TypeInfo,Boolean,String> conversion) { if (type.isParameterized()) { String ret = String.join(", ", ((ParameterizedTypeInfo)type) .getArgs().stream() .map(arg -> conversion.apply(arg, convert)) .collect(Collectors.toList())); if (!ret.isEmpty()) { return "[" + ret + "]"; } } return ""; }
assertEquals(colTypeParams.get(idx), col.getParams().stream().map(TypeParamInfo::getName).collect(Collectors.toList())); ParameterizedTypeInfo ofString = (ParameterizedTypeInfo) map.get(colType + "OfString"); assertEquals(colKind, ofString.getKind()); assertEquals(ParameterizedTypeInfo.class, ofString.getClass()); assertEquals(col, ofString.getRaw()); assertEquals(map.get("String"), ofString.getArg(typeParamIndex)); ParameterizedTypeInfo ofClassTypeParam = (ParameterizedTypeInfo) map.get(colType + "OfClassTypeParam"); assertEquals(colKind, ofClassTypeParam.getKind()); assertEquals(ParameterizedTypeInfo.class, ofClassTypeParam.getClass()); assertEquals(col, ofClassTypeParam.getRaw()); assertEquals(map.get("ClassTypeParam"), ofClassTypeParam.getArg(typeParamIndex)); ParameterizedTypeInfo ofMethodTypeParam = (ParameterizedTypeInfo) map.get(colType + "OfMethodTypeParam"); assertEquals(colKind, ofMethodTypeParam.getKind()); assertEquals(ParameterizedTypeInfo.class, ofMethodTypeParam.getClass()); assertEquals(col, ofMethodTypeParam.getRaw()); assertEquals(1 + typeParamIndex, ofMethodTypeParam.getArgs().size()); TypeParamInfo.Method methodTypeParam = (TypeParamInfo.Method) ((TypeVariableInfo) ofMethodTypeParam.getArg(typeParamIndex)).getParam(); assertEquals("MethodTypeParam", methodTypeParam.getName()); ParameterizedTypeInfo ofDataObject = (ParameterizedTypeInfo) map.get(colType + "OfDataObject"); assertEquals(colKind, ofDataObject.getKind()); assertEquals(ParameterizedTypeInfo.class, ofDataObject.getClass()); assertEquals(map.get("DataObject"), ofDataObject.getArg(typeParamIndex)); ParameterizedTypeInfo ofJsonObject = (ParameterizedTypeInfo) map.get(colType + "OfJsonObject"); assertEquals(colKind, ofJsonObject.getKind()); assertEquals(ParameterizedTypeInfo.class, ofJsonObject.getClass()); assertEquals(map.get("JsonObject"), ofJsonObject.getArg(typeParamIndex)); ParameterizedTypeInfo ofJsonArray = (ParameterizedTypeInfo) map.get(colType + "OfJsonArray"); assertEquals(colKind, ofJsonArray.getKind()); assertEquals(ParameterizedTypeInfo.class, ofJsonArray.getClass());
@Test public void testValidVoidTypeArg() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidVoidTypeArg.class); assertEquals(1, model.getMethods().size()); MethodInfo mi = model.getMethods().get(0); assertEquals("foo", mi.getName()); assertEquals(new ParameterizedTypeInfo(new ClassTypeInfo(ClassKind.API, GenericInterface.class.getName(), null, false, Collections.emptyList()), false, Arrays.asList(TypeReflectionFactory.create(Void.class))), mi.getParams().get(0).getType()); ParameterizedTypeInfo genericType = (ParameterizedTypeInfo) mi.getParams().get(0).getType(); ClassTypeInfo voidType = (ClassTypeInfo) genericType.getArgs().get(0); assertEquals(ClassKind.VOID, voidType.getKind()); }
@Test public void testMethodWithTypeVarParamByGenericType() throws Exception { Runnable test = () -> { try { ClassModel model = new GeneratorHelper().generateClass(MethodWithTypeVarParamByGenericType.class); MethodInfo meth = model.getMethods().get(0); ParamInfo param = meth.getParam(0); ParameterizedTypeInfo handler = (ParameterizedTypeInfo) param.getType(); assertEquals(Handler.class.getName(), handler.getRaw().getName()); ParameterizedTypeInfo genericInt2 = (ParameterizedTypeInfo) handler.getArg(0); assertEquals(GenericInterface2.class.getName(), genericInt2.getRaw().getName()); TypeVariableInfo k = (TypeVariableInfo) genericInt2.getArg(0); assertEquals("K", k.getName()); TypeVariableInfo v = (TypeVariableInfo) genericInt2.getArg(1); assertEquals("V", v.getName()); } catch (Exception e) { throw new AssertionError(e); } }; blacklist(test, Stream.of(WriteStream.class)); test.run(); }
@Override public TypeInfo getErased() { return new io.vertx.codegen.type.ParameterizedTypeInfo(raw, nullable, args.stream().map(TypeInfo::getErased).collect(Collectors.toList())); }
@Test public void testStream() throws Exception { doTest(StreamHolder.class, map -> { ApiTypeInfo readStreamOfString = assertApi(assertParameterized(map.get("readStreamOfString"), "io.vertx.core.streams.ReadStream<java.lang.String>", ClassKind.API).getRaw(), "io.vertx.core.streams.ReadStream"); assertTypeVariable(readStreamOfString.getReadStreamArg(), "T"); ApiTypeInfo extendsReadStreamWithClassArg = assertApi(map.get("extendsReadStreamWithClassArg"), InterfaceExtentingReadStream.class.getName()); assertClass(extendsReadStreamWithClassArg.getReadStreamArg(), "java.lang.String", ClassKind.STRING); ApiTypeInfo extendsGenericReadStreamSubTypeWithClassArg = assertApi(map.get("extendsGenericReadStreamSubTypeWithClassArg"), InterfaceSubtypingReadStream.class.getName()); assertClass(extendsGenericReadStreamSubTypeWithClassArg.getReadStreamArg(), "java.lang.String", ClassKind.STRING); ApiTypeInfo genericReadStreamSubTypeWithClassTypeParamArg = assertApi(assertParameterized(map.get("genericReadStreamSubTypeWithClassTypeParamArg"), ReadStreamWithParameterizedTypeArg.class.getName() + "<ClassTypeParam>", ClassKind.API).getRaw(), "io.vertx.test.codegen.testapi.streams.ReadStreamWithParameterizedTypeArg"); // Cannot assert the correct value for now becasue Java does not provide enough info }); }
@Test public void testGetErased() { abstract class Container<M> implements AsyncResult<List<M>> {} abstract class Expected implements AsyncResult<List<Object>> {} ParameterizedTypeInfo info = (ParameterizedTypeInfo) TypeReflectionFactory.create(Container.class.getGenericInterfaces()[0]); ParameterizedTypeInfo expected = (ParameterizedTypeInfo) TypeReflectionFactory.create(Expected.class.getGenericInterfaces()[0]); assertEquals(expected, info.getErased()); } }
private boolean isLegalFunctionType(TypeInfo typeInfo, boolean allowAnyJavaType) { if (typeInfo.getErased().getKind() == ClassKind.FUNCTION) { TypeInfo paramType = ((ParameterizedTypeInfo) typeInfo).getArgs().get(0); if (isLegalCallbackValueType(paramType, allowAnyJavaType) || paramType.getKind() == ClassKind.THROWABLE) { TypeInfo returnType = ((ParameterizedTypeInfo) typeInfo).getArgs().get(1); return isLegalNonCallableParam(returnType, allowAnyJavaType); } } return false; }
protected final String genTypeName(TypeInfo type) { if (type.isParameterized()) { ParameterizedTypeInfo pt = (ParameterizedTypeInfo) type; return genTypeName(pt.getRaw()) + pt.getArgs().stream().map(this::genTypeName).collect(Collectors.joining(", ", "<", ">")); } else if (type.getKind() == ClassKind.API) { return type.translateName(id); } else { return type.getSimpleName(); } }
collect(Collectors.toList()); Type raw = parameterizedType.getRawType(); return new ParameterizedTypeInfo((ClassTypeInfo) create(raw), false, args); } else if (type instanceof java.lang.reflect.TypeVariable) { java.lang.reflect.TypeVariable typeVar = (java.lang.reflect.TypeVariable) type;
public static boolean isAsyncResultHandler(TypeInfo type) { return type.getKind() == ClassKind.HANDLER && ((ParameterizedTypeInfo)type).getArg(0).getKind() == ClassKind.ASYNC_RESULT; }
ClassKind kind = returnType.getKind(); if (kind == LIST || kind == SET) { TypeInfo elementType = ((ParameterizedTypeInfo) returnType).getArg(0); ClassKind elementKind = elementType.getKind(); if (elementKind.json) { writer.format("utils.convReturnVertxGen(%s, %s", returnType.getRaw().getSimpleName(), templ); if (returnType.isParameterized()) { for (TypeInfo arg : ((ParameterizedTypeInfo) returnType).getArgs()) { ClassKind argKind = arg.getKind(); if (argKind == API) { } else if (kind == HANDLER) { ParameterizedTypeInfo type = (ParameterizedTypeInfo) returnType; if (type.getArg(0).getKind() == ASYNC_RESULT) { return String.format("utils.convReturnHandlerAsyncResult(%s, function(result) { return %s; })", templ, convParam(model, method, null, false, new ParamInfo(0, "result", null, (((ParameterizedTypeInfo) (type).getArg(0))).getArg(0)))); } else { return String.format("utils.convReturnHandler(%s, function(result) { return %s; })", templ, convParam(model, method, null, false, new ParamInfo(0, "result", null, type.getArg(0))));
private static boolean containsAnyJavaType(TypeInfo type) { if (type instanceof ParameterizedTypeInfo) { return containsAnyJavaType(type.getRaw()) || ((ParameterizedTypeInfo) type).getArgs().stream().anyMatch(MethodInfo::containsAnyJavaType); } else { return type.getKind() == ClassKind.OTHER; } }
@Test public void testReadStreamWithParameterizedTypeArg() throws Exception { ClassModel model = new GeneratorHelper().generateClass(ReadStreamWithParameterizedTypeArg.class); ApiTypeInfo apiType = (ApiTypeInfo) model.getType().getRaw(); assertTrue(apiType.isReadStream()); ParameterizedTypeInfo readStreamArg = (ParameterizedTypeInfo) apiType.getReadStreamArg(); assertEquals(TypeReflectionFactory.create(List.class), readStreamArg.getRaw()); assertEquals(1, readStreamArg.getArgs().size()); assertEquals("T", readStreamArg.getArgs().get(0).getName()); assertFalse(apiType.isWriteStream()); assertNull(apiType.getWriteStreamArg()); assertFalse(apiType.isHandler()); }
private MethodInfo genOverloadedMethod(MethodInfo method, Class streamType) { List<ParamInfo> params = null; int count = 0; for (ParamInfo param : method.getParams()) { if (param.getType().isParameterized() && param.getType().getRaw().getName().equals("io.vertx.core.streams.ReadStream")) { if (params == null) { params = new ArrayList<>(method.getParams()); } ParameterizedTypeInfo paramType = new io.vertx.codegen.type.ParameterizedTypeInfo( io.vertx.codegen.type.TypeReflectionFactory.create(streamType).getRaw(), false, java.util.Collections.singletonList(((ParameterizedTypeInfo) param.getType()).getArg(0)) ); params.set(count, new io.vertx.codegen.ParamInfo( param.getIndex(), param.getName(), param.getDescription(), paramType )); } count = count + 1; } if (params != null) { return method.copy().setParams(params); } return null; } }
return new ParameterizedTypeInfo(raw, nullable, typeArguments); } else { return raw;