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"); } }
protected void startMethodTemplate(ClassTypeInfo type, MethodInfo method, String deprecated, PrintWriter writer) { Doc doc = method.getDoc(); if (doc != null) { writer.println(" /**"); Token.toHtml(doc.getTokens(), " *", this::renderLinkToHtml, "\n", writer); for (ParamInfo param : method.getParams()) { writer.print(" * @param "); writer.print(param.getName()); if (!method.getReturnType().getName().equals("void")) { writer.print(" * @return "); if (method.getReturnDescription() != null) { Token.toHtml(method.getReturnDescription().getTokens(), "", this::renderLinkToHtml, "", writer); if (method.isDeprecated() || deprecated != null && deprecated.length() > 0) { writer.println(" @Deprecated()"); if (method.isStaticMethod()) { writer.print("static "); if (method.getTypeParams().size() > 0) { writer.print(method.getTypeParams().stream().map(TypeParamInfo::getName).collect(Collectors.joining(", ", "<", ">"))); writer.print(" "); writer.print(genTypeName(method.getReturnType())); writer.print(" "); writer.print(method.getName()); writer.print("("); writer.print(method.getParams().stream().map(it -> genTypeName(it.getType()) + " " + it.getName()).collect(Collectors.joining(", "))); writer.print(")");
startMethodTemplate(type, method, "", writer); writer.println(" { "); if (method.isFluent()) { writer.print(" "); writer.print(genInvokeDelegate(model, method)); writer.println(";"); if (method.getReturnType().isVariable()) { writer.print(" return ("); writer.print(method.getReturnType().getName()); writer.println(") this;"); } else { writer.println(" return this;"); } else if (method.getReturnType().getName().equals("void")) { writer.print(" "); writer.print(genInvokeDelegate(model, method)); writer.println(";"); } else { if (method.isCacheReturn()) { writer.print(" if (cached_"); writer.print(cacheDecls.size()); TypeInfo returnType = method.getReturnType(); if (method.getReturnType().getKind() == PRIMITIVE) { cachedType = ((PrimitiveTypeInfo) returnType).getBoxed().getName(); } else { writer.print(genConvReturn(returnType, method, genInvokeDelegate(model, method))); writer.println(";");
private boolean generateFilter(MethodInfo it) { MethodKind methodKind = it.getKind(); return !it.isDeprecated() && (it.isFluent() || it.getReturnType().isVoid()) && methodKind == MethodKind.FUTURE; }
protected void checkMethod(MethodInfo methodInfo) { List<MethodInfo> methodsByName = methodMap.get(methodInfo.getName()); if (methodsByName != null) { // Overloaded methods must have same return type for (MethodInfo meth: methodsByName) { if (!meth.isContainingAnyJavaType() && !meth.getReturnType().equals(methodInfo.getReturnType())) { throw new GenException(this.modelElt, "Overloaded method " + methodInfo.getName() + " must have the same return type " + meth.getReturnType() + " != " + methodInfo.getReturnType()); } } } }
public static List<MethodInfo> findBasicMethods(List<MethodInfo> methods) { return methods.stream() .filter(method -> !method.isFluent() && !method.isCacheReturn() && !method.isStaticMethod() && !method.isDefaultMethod() && !skipMethod(method)) .collect(Collectors.toList()); }
void checkMethod(MethodInfo meth, String name, int numParams, String returnType, MethodKind kind, Doc comment, MethodCheck... checks) { EnumSet<MethodCheck> checkSet = EnumSet.noneOf(MethodCheck.class); Collections.addAll(checkSet, checks); assertEquals(name, meth.getName()); if (comment != null) { assertNotNull(meth.getComment()); assertEquals(comment.getFirstSentence(), meth.getDoc().getFirstSentence()); assertEquals(comment.getBody(), meth.getDoc().getBody()); assertEquals(comment.getBlockTags(), meth.getDoc().getBlockTags()); } else { assertNull(meth.getComment()); } assertEquals(kind, meth.getKind()); assertEquals(returnType, meth.getReturnType().toString()); assertEquals(checkSet.contains(MethodCheck.CACHE_RETURN), meth.isCacheReturn()); assertEquals(checkSet.contains(MethodCheck.FLUENT), meth.isFluent()); assertEquals(checkSet.contains(MethodCheck.STATIC), meth.isStaticMethod()); assertEquals(numParams, meth.getParams().size()); }
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 sortMethodMap(Map<String, List<MethodInfo>> map) { for (List<MethodInfo> list: map.values()) { list.sort(Comparator.comparingInt(meth -> meth.getParams().size())); } }
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"); } } }
String simpleName = model.getType().getSimpleName(); String ifaceName = Helper.decapitaliseFirstLetter(simpleName); if (method.isStaticMethod()) { writer.format("J%s", simpleName); } else { writer.format("j_%s", ifaceName); writer.format("[\"%s(", method.getName()); boolean first = true; for (ParamInfo param : method.getParams()) { if (first) { first = false; int pcnt = 0; first = true; for (ParamInfo param : method.getParams()) { if (first) { first = false;
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()); }
private void generateMethod(ClassModel model, ClassTypeInfo type, MethodInfo method, CodeWriter writer, boolean hasStatic) { generateDoc(model, method, writer.writer()); writer.print("suspend fun "); if (!method.getTypeParams().isEmpty() || !type.getParams().isEmpty()) { String typeParamInfo = Stream .concat( method.getTypeParams().stream(), type.getParams().stream()) .map(TypeParamInfo::getName) if (!method.isStaticMethod()) { writer.print(vertxSimpleNameWrapper(type.getSimpleName(), hasStatic)); if (!type.getParams().isEmpty()) { writer.print(method.getName()); writer.print("Await("); List<ParamInfo> params = method.getParams(); writer.print(params.stream() .limit(params.size() - 1) TypeInfo returnType; String awaitCallMethod; if (method.getKind() == MethodKind.HANDLER) { returnType = handlerArg; awaitCallMethod = "awaitEvent"; if (method.isStaticMethod()) { writer.print(vertxSimpleNameWrapper(type.getSimpleName(), hasStatic)); } else {
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); }); }
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 + ")"; }
@Override protected void genRxMethod(ClassModel model, MethodInfo method, PrintWriter writer) { MethodInfo futMethod = genFutureMethod(method); ClassTypeInfo raw = futMethod.getReturnType().getRaw(); String methodSimpleName = raw.getSimpleName(); String adapterType = "io.vertx.reactivex.impl.AsyncResult" + methodSimpleName + ".to" + methodSimpleName; String rxType = raw.getName(); startMethodTemplate(model.getType(), futMethod, "", writer); writer.println(" { "); writer.print(" return "); writer.print(adapterType); writer.println("(handler -> {"); writer.print(" "); writer.print(method.getName()); writer.print("("); List<ParamInfo> params = futMethod.getParams(); writer.print(params.stream().map(ParamInfo::getName).collect(Collectors.joining(", "))); if (params.size() > 0) { writer.print(", "); } writer.println("handler);"); writer.println(" });"); writer.println(" }"); writer.println(); }
public static boolean isMethodNeedsOverride(String callingClassName, MethodInfo method) { if (method.getName().equals("toString") && method.getParams().isEmpty()) { return true; } else { /*There is only one entry in here (0 would be a bug)*/ for (ClassTypeInfo ownerType : method.getOwnerTypes()) { if (!ownerType.getName().equals(callingClassName)) { return true; } } return false; } }
public static boolean shouldMethodReturnAFuture(MethodInfo method) { int size = method.getParams().size(); return size > 0 && isLastParamAsyncResultHandler(method) && !(method.getReturnType().getKind() == ClassKind.HANDLER); }
@Test public void testMethodOverride() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithMethodOverride.class, VertxGenInterface.class); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "bar", 1, "void", MethodKind.OTHER); assertEquals(set( TypeReflectionFactory.create(InterfaceWithMethodOverride.class), TypeReflectionFactory.create(VertxGenInterface.class) ), methods.get(0).getOwnerTypes()); checkParam(methods.get(0).getParams().get(0), "str", String.class); }