@Override public String getSimpleName() { return componentType.getSimpleName() + "[]"; }
public static String renderDataObjectHtmlLink(TypeInfo type, TypeInfo dataObjectType) { StringBuilder link = new StringBuilder(); for (String name : Case.QUALIFIED.parse(type.getRaw().getPackageName())) { link.append("../"); } link.append("../../../cheatsheet/").append(dataObjectType.getSimpleName()).append(".html"); return "<a href=\"" + link + "\">" + dataObjectType.getSimpleName() + "</a>"; }
public Set<String> adjustedImports(ClassTypeInfo type, Set<TypeInfo> importedTypes, Set<TypeInfo> superTypes) { Set<String> imps = TypeHelper.generateImports(type, importedTypes, Collections.emptyList()); for (TypeInfo superType : superTypes) { imps.remove(superType.getRaw().translatePackageName("scala")+'.'+superType.getSimpleName()); imps.remove(convertTypeToAliasedType(superType)); } for (TypeInfo superType : superTypes) { imps.add(superType.getRaw().translatePackageName("scala") + ".{" + superType.getSimpleName() + " => Ext" + superType.getSimpleName() + "}"); } imps.add("io.vertx.lang.scala.json.Json._"); imps.add("io.vertx.core.json.JsonObject"); imps.add("scala.collection.JavaConverters._"); return imps; }
private String kotlinType(TypeInfo type) { if (type instanceof VoidTypeInfo) { return "Unit"; } else if (type instanceof PrimitiveTypeInfo) { return Case.CAMEL.format(Collections.singletonList(type.getSimpleName())); } else if (type.getKind() == ClassKind.BOXED_PRIMITIVE) { switch (type.getSimpleName()) { case "Integer": return "Int"; case "Character": return "Char"; default: return type.getSimpleName(); } } else if ("java.lang.Void".equals(type.getName())) { return "Unit"; } else if ("java.lang.Object".equals(type.getName())) { return "Any"; } else { if (type instanceof ParameterizedTypeInfo) { List<TypeInfo> args = ((ParameterizedTypeInfo) type).getArgs(); return type.getRaw().getSimpleName() + args.stream().map(this::kotlinType).collect(Collectors.joining(",", "<", ">")); } else { return type.getSimpleName(); } } }
/** * Every usage of a Vert.x-Java-type has to be aliased. This takes care of generating the required snippet. */ public static String convertTypeToAliasedType(TypeInfo type) { return Helper.getPackageName(getNonGenericType(type.getName())) + ".{"+getNonGenericType(type.getSimpleName())+" => J"+getNonGenericType(type.getSimpleName())+"}"; }
public static boolean isImported(TypeInfo ref, Map<String, Object> session) { if (ref.getRaw().getModuleName() == null) { return true; } final String key = ref.getRaw().getModuleName() + "/" + ref.getSimpleName(); if (!session.containsKey(key)) { session.put(key, ref); return false; } return true; }
private void genToXXXEr(TypeInfo streamType, String rxType, String rxName, PrintWriter writer) { writer.format(" public synchronized io.vertx.reactivex.WriteStream%s<%s> to%s() {%n", rxType, genTypeName(streamType), rxType); writer.format(" if (%s == null) {%n", rxName); if (streamType.getKind() == ClassKind.API) { writer.format(" java.util.function.Function<%s, %s> conv = %s::getDelegate;%n", genTypeName(streamType.getRaw()), streamType.getName(), genTypeName(streamType)); writer.format(" %s = io.vertx.reactivex.RxHelper.to%s(getDelegate(), conv);%n", rxName, rxType); } else if (streamType.isVariable()) { String typeVar = streamType.getSimpleName(); writer.format(" java.util.function.Function<%s, %s> conv = (java.util.function.Function<%s, %s>) __typeArg_0.unwrap;%n", typeVar, typeVar, typeVar, typeVar); writer.format(" %s = io.vertx.reactivex.RxHelper.to%s(getDelegate(), conv);%n", rxName, rxType); } else { writer.format(" %s = io.vertx.reactivex.RxHelper.to%s(getDelegate());%n", rxName, rxType); } writer.println(" }"); writer.format(" return %s;%n", rxName); writer.println(" }"); writer.println(); }
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(); } }
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(); } }
writer.println("(delegate, conv);"); } else if (streamType.isVariable()) { String typeVar = streamType.getSimpleName(); writer.print(" java.util.function.Function<"); writer.print(typeVar);
private String sendTypeParameter(TypeInfo t) { if (t.getKind() == ClassKind.LIST || t.getKind() == ClassKind.SET) return "JsonArray"; if (t.getKind() == ClassKind.DATA_OBJECT) return "JsonObject"; if (t.getKind() == ClassKind.ENUM) return "String"; return t.getSimpleName(); } }
private void genConstant(ClassModel model, ConstantInfo constant, PrintWriter writer) { Doc doc = constant.getDoc(); if (doc != null) { writer.println(" /**"); Token.toHtml(doc.getTokens(), " *", this::renderLinkToHtml, "\n", writer); writer.println(" */"); } writer.print(model.isConcrete() ? " public static final" : ""); writer.println(" " + constant.getType().getSimpleName() + " " + constant.getName() + " = " + genConvReturn(constant.getType(), null, model.getType().getName() + "." + constant.getName()) + ";"); }
private void genConstant(ClassModel model, ConstantInfo constant, PrintWriter writer) { Doc doc = constant.getDoc(); if (doc != null) { writer.println(" /**"); Token.toHtml(doc.getTokens(), " *", this::renderLinkToHtml, "\n", writer); writer.println(" */"); } writer.print(model.isConcrete() ? " public static final" : ""); writer.println(" " + constant.getType().getSimpleName() + " " + constant.getName() + " = " + genConvReturn(constant.getType(), null, model.getType().getName() + "." + constant.getName()) + ";"); }
genPropToJson("", "", prop, writer); } else { switch (prop.getType().getSimpleName()) { case "char": case "Character":
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"); } } }
|| type.getName().equals("void") || type.getName().equals("io.vertx.core.buffer.Buffer")) { return type.getSimpleName(); } else if (type.getKind() == ClassKind.OBJECT) { if (convertTypeParamsToObject) { return "Object"; } else { return type.getSimpleName(); return "J" + type.getSimpleName(); } else if (type.getKind() == ClassKind.API) { String ret = "J" + getNonGenericType(type.getSimpleName()); if (type.isParameterized()) { ret += convertJavaArgListToString(type, convertTypeParamsToObject); String ret = type.getSimpleName(); String args = convertJavaArgListToString(type, convertTypeParamsToObject); return ret + "[" + args + "]"; } else if (type.getKind() == ClassKind.ASYNC_RESULT) { ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; return getNonGenericType(type.getSimpleName()) + "["+ toJavaType(parameterizedType.getArg(0), convertTypeParamsToObject) +"]"; } else { return "Unknown type for toJavaType "+type.getName()+" "+type.getKind();
case "java.lang.Double": case "double": return "Number (" + type.getSimpleName() + ")";
@Test public void testEnumListingFromApi() throws Exception { ClassModel model = new GeneratorHelper().generateClass(EnumAsParam.class); assertTrue(model.getReferencedEnumTypes().size() > 0); TypeInfo typeInfo = (TypeInfo) model.getReferencedEnumTypes().toArray()[0]; assertTrue(typeInfo instanceof EnumTypeInfo); assertEquals("ValidEnum", typeInfo.getSimpleName()); } }
case PRIMITIVE: case BOXED_PRIMITIVE: switch (type.getSimpleName()) { case "boolean": case "Boolean":
" } else {\n" + " String proxyAddress = UUID.randomUUID().toString();\n" + " ProxyHelper.registerService(" + typeArg.getSimpleName() + ".class, vertx, res.result(), proxyAddress, false, timeoutSeconds);\n" + " msg.reply(null, new DeliveryOptions().addHeader(\"proxyaddr\", proxyAddress));\n" + " }\n" +