@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(); } }
public static String invokeStaticMethod(String target, TypeInfo type, MethodInfo method) { /*class level typeparams aren"t needed for static methods*/ List<TypeParamInfo> typeParams = Collections.emptyList(); String paramString = String.join(", ", method.getParams().stream() .map(param -> toJavaWithConversion(escapeIfKeyword(param.getName()), param.getType(), typeParams, method.getTypeParams())) .collect(Collectors.toList())); String typeParamString = ""; if (!method.getTypeParams().isEmpty()) { typeParamString = String.join(", ", method.getTypeParams().stream() .map(param -> "Object") .collect(Collectors.toList())); typeParamString = "[" + typeParamString + "]"; } return toScalaWithConversion(target + "." + escapeIfKeyword(method.getName()) + typeParamString + "(" + paramString + ")", method.getReturnType(), typeParams, method.getTypeParams()); }
public static String invokeMethodWithoutConvertingReturn(String target, TypeInfo type, MethodInfo method, Collection<TypeParamInfo> typeParams) { String paramString = String.join(", ", method.getParams().stream() .map(param -> toJavaWithConversion(escapeIfKeyword(param.getName()), param.getType(), typeParams, method.getTypeParams())) .collect(Collectors.toList())); return target + "." + escapeIfKeyword(method.getName()) + assembleTypeParamString(method) + "(" + paramString + ")"; }
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); }); }
for (ParamInfo param : method.getParams()) { writer.print(" * @param "); writer.print(param.getName()); writer.print(" "); if (param.getDescription() != null) { writer.print(method.getName()); writer.print("("); writer.print(method.getParams().stream().map(it -> genTypeName(it.getType()) + " " + it.getName()).collect(Collectors.joining(", "))); writer.print(")");
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; }
adapterFunction = "obj -> (" + parameterizedType.getArg(0).getRaw().getName() + ")obj.getDelegate()"; ret.append("io.vertx.rx.java.ReadStreamSubscriber.asReadStream(").append(param.getName()).append(",").append(adapterFunction).append(").resume()"); } else if (type.isParameterized() && (type.getRaw().getName().equals("io.reactivex.Flowable") || type.getRaw().getName().equals("io.reactivex.Observable"))) { String adapterFunction; adapterFunction = "obj -> (" + parameterizedType.getArg(0).getRaw().getName() + ")obj.getDelegate()"; ret.append("io.vertx.reactivex.impl.ReadStreamSubscriber.asReadStream(").append(param.getName()).append(",").append(adapterFunction).append(").resume()"); } else { ret.append(genConvParam(type, method, param.getName()));
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; }
adapterFunction = "obj -> (" + parameterizedType.getArg(0).getRaw().getName() + ")obj.getDelegate()"; ret.append("io.vertx.rx.java.ReadStreamSubscriber.asReadStream(").append(param.getName()).append(",").append(adapterFunction).append(").resume()"); } else if (type.isParameterized() && (type.getRaw().getName().equals("io.reactivex.Flowable") || type.getRaw().getName().equals("io.reactivex.Observable"))) { String adapterFunction; adapterFunction = "obj -> (" + parameterizedType.getArg(0).getRaw().getName() + ")obj.getDelegate()"; ret.append("io.vertx.reactivex.impl.ReadStreamSubscriber.asReadStream(").append(param.getName()).append(",").append(adapterFunction).append(").resume()"); } else { ret.append(genConvParam(type, method, param.getName()));
public String generateJsonParamExtract(ParamInfo param) { String name = param.getName(); TypeInfo type = param.getType(); String typeName = type.getName();
if (param.getDescription() != null) { doc += commentedIndentation; doc += " @param " + param.getName()+ " "; doc += convertLink(param.getDescription()); if (param.getType().getKind() == ClassKind.DATA_OBJECT) {
public static String invokeMethodAndUseProvidedHandler(String target, TypeInfo type, MethodInfo method, Collection<TypeParamInfo> typeParams, String handler) { String typeParamString = assembleTypeParamString(method); String paramString = ""; for (ParamInfo param : method.getParams()) { if (!paramString.equals("")) { paramString += ", "; } if (isAsyncResultHandler(param.getType())) { paramString += handler; } else { paramString += toJavaWithConversion(escapeIfKeyword(param.getName()), param.getType(), typeParams, method.getTypeParams()); } } return target + "." + escapeIfKeyword(method.getName()) + typeParamString + "(" + paramString + ")"; }
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 void generateMethods(ProxyModel model, CodeWriter writer) { for (MethodInfo m : model.getMethods()) { if (!m.isStaticMethod()) { writer.code("@Override\n"); writer.code("public "); if (!m.getTypeParams().isEmpty()) { writer.write("<"); writer.writeSeq(m.getTypeParams().stream().map(TypeParamInfo::getName), ", "); writer.write(">"); } writer.write(" " + m.getReturnType().getSimpleName() + " " + m.getName() + "("); writer.writeSeq(m.getParams().stream().map(p -> p.getType().getSimpleName() + " " + p.getName()), ", "); writer.write("){\n"); writer.indent(); if (!((ProxyMethodInfo) m).isProxyIgnore()) generateMethodBody((ProxyMethodInfo) m, writer); if (m.isFluent()) writer.stmt("return this"); writer.unindent(); writer.code("}\n"); } } }
writer.code("if (closed) {\n"); writer.indent(); writer.stmt(lastParam.getName() + ".handle(Future.failedFuture(new IllegalStateException(\"Proxy is closed\")))"); if (method.isFluent()) writer.stmt("return this");
@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 void generateMethod(PrintWriter writer, ClassTypeInfo type, MethodInfo method) { generateDoc(writer, method.getDoc()); if (getOverrideArgs(type.getSimpleName(), method.getName()) != null) { writer.printf(" %s%s%s(%s", method.isStaticMethod() ? "static " : "", method.getName(), genGeneric(method.getTypeParams()), getOverrideArgs(type.getSimpleName(), method.getName())); } else { writer.printf(" %s%s%s(", method.isStaticMethod() ? "static " : "", method.getName(), genGeneric(method.getTypeParams())); boolean more = false; for (ParamInfo param : method.getParams()) { if (more) { writer.print(", "); } writer.printf("%s: %s%s", cleanReserved(param.getName()), genType(param.getType()), param.getType().isNullable() ? " | null | undefined" : ""); more = true; } } if (getOverrideReturn(type.getSimpleName(), method.getName()) != null) { writer.printf(") : %s%s;\n", getOverrideReturn(type.getSimpleName(), method.getName()), method.getReturnType().isNullable() ? " | null" : ""); } else { writer.printf(") : %s%s;\n", genType(method.getReturnType()), method.getReturnType().isNullable() ? " | null" : ""); } } }
private void generateAddToJsonStmt(ParamInfo param, CodeWriter writer) { TypeInfo t = param.getType(); String name = param.getName(); if ("char".equals(t.getName())) writer.stmt("_json.put(\"" + name + "\", (int)" + name + ")"); else if ("java.lang.Character".equals(t.getName())) writer.stmt("_json.put(\"" + name + "\", " + name + " == null ? null : (int)" + name + ")"); else if (t.getKind() == ClassKind.ENUM) writer.stmt("_json.put(\"" + name + "\", " + name + " == null ? null : " + name + ".toString())"); else if (t.getKind() == ClassKind.LIST) { if (((ParameterizedTypeInfo)t).getArg(0).getKind() == ClassKind.DATA_OBJECT) writer.stmt("_json.put(\"" + name + "\", new JsonArray(" + name + " == null ? java.util.Collections.emptyList() : " + name + ".stream().map(r -> r == null ? null : r.toJson()).collect(Collectors.toList())))"); else writer.stmt("_json.put(\"" + name + "\", new JsonArray(" + name + "))"); } else if (t.getKind() == ClassKind.SET) { if (((ParameterizedTypeInfo)t).getArg(0).getKind() == ClassKind.DATA_OBJECT) writer.stmt("_json.put(\"" + name + "\", new JsonArray(" + name + " == null ? java.util.Collections.emptyList() : " + name + ".stream().map(r -> r == null ? null : r.toJson()).collect(Collectors.toList())))"); else writer.stmt("_json.put(\"" + name + "\", new JsonArray(new ArrayList<>(" + name + ")))"); } else if (t.getKind() == ClassKind.MAP) writer.stmt("_json.put(\"" + name + "\", new JsonObject(ProxyUtils.convertMap(" + name + ")))"); else if (t.getKind() == ClassKind.DATA_OBJECT) writer.stmt("_json.put(\"" + name + "\", " + name + " == null ? null : " + name + ".toJson())"); else writer.stmt("_json.put(\"" + name + "\", " + name + ")"); }
void checkParam(ParamInfo param, String name, Type expectedType) { assertEquals(name, param.getName()); TypeInfo expectedTypeInfo = TypeReflectionFactory.create(expectedType); assertEquals(expectedTypeInfo.getName(), param.getType().getName()); assertEquals(expectedTypeInfo.getKind(), param.getType().getKind()); }