@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append(name); sb.append('('); if (params.size() > 0) { for (int i = 0;i < params.size();i++) { if (i > 0) { sb.append(", "); } sb.append(params.get(i).getType().getName()).append(" ").append(params.get(i).getName()); } } sb.append(')'); return sb.toString(); } }
for (ParamInfo param : method.getParams()) { writer.print(" * @param "); writer.print(param.getName()); writer.print(" "); if (param.getDescription() != null) { Token.toHtml(param.getDescription().getTokens(), "", this::renderLinkToHtml, "", writer); writer.print(method.getName()); writer.print("("); writer.print(method.getParams().stream().map(it -> genTypeName(it.getType()) + " " + it.getName()).collect(Collectors.joining(", "))); writer.print(")");
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; } }
private Stream<SimpleMethod> convert(Stream<MethodInfo> meths) { return meths.map(meth -> { List<SimpleParam> simpleParams = new ArrayList<>(); for (ParamInfo param: meth.getParams()) { TypeInfo type = param.getType(); simpleParams.add(new SimpleParam(param.getName(), type.getKind(), param.isNullable(), type.getName())); } return new SimpleMethod(meth.getName(), simpleParams); }); }
writer.format(" @param %s {%s} ", param.getName(), getJSDocType(param.getType())); if (param.getDescription() != null) { Token.toHtml(param.getDescription().getTokens(), "", this::renderLinkToHtml, "", writer); writer.print(" "); switch (param.getType().getKind()) { case PRIMITIVE: case BOXED_PRIMITIVE: if (param.isNullable()) { writer.print("("); String paramSimpleName = param.getType().getSimpleName(); if ("boolean".equalsIgnoreCase(paramSimpleName)) { writer.print("'boolean'"); if (param.isNullable()) { writer.format(" || __args[%s] == null)", cnt); case STRING: case ENUM: if (param.isNullable()) { writer.print("("); if (param.isNullable()) { writer.format(" || __args[%s] == null)", cnt); case API: writer.format("typeof __args[%s] === 'object' && ", cnt); if (param.isNullable()) {
writer.print(params.stream() .limit(params.size() - 1) .map(p -> p.getName() + " : " + kotlinType(p.getType())) .collect(Collectors.joining(", "))); writer.print(")"); ParamInfo lastParam = params.get(params.size() - 1); ParameterizedTypeInfo lastParamType = (ParameterizedTypeInfo) lastParam.getType(); TypeInfo handlerArg = lastParamType.getArg(0); TypeInfo returnType; if (lastParam.isNullableCallback()) { writer.print("?"); writer.print(params.stream() .limit(params.size() - 1) .map(p -> keyWordConverter(p.getName())) .collect(Collectors.joining(", "))); if (params.size() > 1) {
private void generateDoc(ClassModel model, MethodInfo method, PrintWriter writer) { Doc doc = method.getDoc(); if (doc != null) { writer.print("/**\n"); Token.toHtml(doc.getTokens(), " *", KotlinCodeGenHelper::renderLinkToHtml, "\n", writer); writer.print(" *\n"); method.getParams() .stream() .limit(method.getParams().size() - 1) .forEach(p -> { writer.print(" * @param " + p.getName() + " "); if (p.getDescription() != null) { String docInfo = Token.toHtml(p.getDescription().getTokens(), "", KotlinCodeGenHelper::renderLinkToHtml, ""); writer.print(docInfo); } writer.print("\n"); }); if (!method.getReturnType().isVoid()) { writer.print(" * @return "); if (method.getReturnDescription() != null) { String docInfo = Token.toHtml(method.getReturnDescription().getTokens(), "", KotlinCodeGenHelper::renderLinkToHtml, ""); writer.print(docInfo); } } writer.print(" *\n"); writer.print(" * <p/>\n"); writer.print(" * NOTE: This function has been automatically generated from the [" + model.getType().getName() + " original] using Vert.x codegen.\n"); writer.print(" */\n"); } }
private String genTypeArg(TypeVariableInfo typeVar, MethodInfo method) { if (typeVar.isClassParam()) { return "__typeArg_" + typeVar.getParam().getIndex(); } else { TypeArgExpression typeArg = method.resolveTypeArg(typeVar); if (typeArg != null) { if (typeArg.isClassType()) { return "io.vertx.lang.rx.TypeArg.of(" + typeArg.getParam().getName() + ")"; } else { return typeArg.getParam().getName() + ".__typeArg_" + typeArg.getIndex(); } } } return null; }
@Test public void testMethodWithOverloadedNullableParam() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 2, "void", MethodKind.OTHER); assertEquals(ClassKind.STRING, mi1.getParams().get(0).getType().getKind()); checkParam(mi1.getParams().get(0), "s", String.class); assertTrue(mi1.getParams().get(0).isNullable()); checkParam(mi1.getParams().get(1), "i", Integer.class); assertFalse(mi1.getParams().get(1).isNullable()); MethodInfo mi2 = methods.get(1); checkMethod(mi2, "method", 2, "void", MethodKind.OTHER); checkParam(mi2.getParams().get(0), "i", Integer.class); assertFalse(mi2.getParams().get(0).isNullable()); checkParam(mi2.getParams().get(1), "s", String.class); assertTrue(mi2.getParams().get(1).isNullable()); }, MethodWithOverloadedNullableParam.class); }
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); }
@Test public void testInterfaceWithNullableParamOverride() throws Exception { Consumer<ClassModel> test = model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); assertTrue(mi1.getParams().get(0).isNullable()); }; // generateClass(test, MethodWithNullableParamOverride.class, MethodWithNullableParam.class); generateClass(test, MethodWithNullableParamOverride.class); }
break; case ENUM: if (param.isNullable()) { writer.format("%s == null ? null : ", unwrappedName); ParamInfo classTypeParam = method.resolveClassTypeParam(type); if (classTypeParam != null) { writer.format("utils.get_jtype(__args[%s]).unwrap(%s)", classTypeParam.getIndex(), unwrappedName); } else { writer.format("utils.convParamTypeUnknown(%s)", unwrappedName); writer.format("utils.convParam%sObject(%s)", container, unwrappedName); } else { if (param.isNullable()) { writer.format("%s == null ? null : ", unwrappedName); if (param.isNullable()) { writer.format("%s == null ? null : ", unwrappedName);
ParamInfo classTypeParam = method != null ? method.resolveClassTypeParam((TypeVariableInfo) arg) : null; if (classTypeParam != null) { writer.format(", utils.get_jtype(__args[%s])", classTypeParam.getIndex()); } else { writer.print(", undefined"); 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)))); return String.format("utils.get_jtype(__args[%s]).wrap(%s)", classTypeParam.getIndex(), templ); } else {
throw new GenException(param, e.getMessage()); ParamInfo mParam = new ParamInfo(i, name, text, typeInfo, unresolvedTypeInfo); mParams.add(mParam);
@Override public int compareTo(MethodInfo o) { int cmp = name.compareTo(o.name); if (cmp != 0) { return cmp; } Iterator<ParamInfo> i1 = params.iterator(); Iterator<ParamInfo> i2 = o.params.iterator(); while (i1.hasNext() && i2.hasNext()) { ParamInfo p1 = i1.next(); ParamInfo p2 = i2.next(); cmp = p1.getType().getRaw().getName().compareTo(p2.getType().getRaw().getName()); if (cmp != 0) { return cmp; } } if (i1.hasNext()) { if (!i2.hasNext()) { return 1; } } else if (!i2.hasNext()) { return -1; } return 0; }
protected String convParam(M model, MethodInfo method, String argName, boolean overloaded, ParamInfo param) { StringWriter buffer = new StringWriter(); CodeWriter writer = new CodeWriter(buffer); String paramName = overloaded ? argName : param.getName(); ClassKind paramKind = param.getType().getKind(); boolean funct = paramKind == FUNCTION; if (paramKind == HANDLER || funct) { ParameterizedTypeInfo type = (ParameterizedTypeInfo) param.getType(); if (type.getArg(0).getKind() == ASYNC_RESULT) { ParameterizedTypeInfo asyncType = (ParameterizedTypeInfo) type.getArg(0); if (param.isNullable()) { writer.format("%s == null ? null : ", paramName); writer.print(paramName); } else { if (param.isNullable()) { writer.print(paramName); writer.print(" == null ? null : "); writer.print(unwrapToJava(method, param, param.getType(), paramName));
@Test public void testMethodComments() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithComments.class); assertEquals(InterfaceWithComments.class.getName(), model.getIfaceFQCN()); assertEquals(InterfaceWithComments.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); Doc comment1 = new Doc(" Comment 1 line 1\n Comment 1 line 2", null, Arrays.asList(new Tag("param", "str the_string"), new Tag("return", "the_return_value\n"))); Doc comment2 = new Doc(" Comment 2 line 1\n Comment 2 line 2\n"); checkMethod(methods.get(0), "foo", 1, String.class, MethodKind.OTHER, comment1); assertEquals("str", methods.get(0).getParams().get(0).getName()); assertEquals("the_string", methods.get(0).getParams().get(0).getDescription().toString()); checkMethod(methods.get(1), "bar", 1, "void", MethodKind.OTHER, comment2); }
private String genTypeArg(TypeVariableInfo typeVar, MethodInfo method) { if (typeVar.isClassParam()) { return "__typeArg_" + typeVar.getParam().getIndex(); } else { TypeArgExpression typeArg = method.resolveTypeArg(typeVar); if (typeArg != null) { if (typeArg.isClassType()) { return "io.vertx.lang.rx.TypeArg.of(" + typeArg.getParam().getName() + ")"; } else { return typeArg.getParam().getName() + ".__typeArg_" + typeArg.getIndex(); } } } return null; }
@Test public void testMethodWithNullableHandler() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 1, "void", MethodKind.HANDLER); assertTrue(mi1.getParams().get(0).isNullable()); }, MethodWithNullableHandler.class); }