private static boolean rawTypeIs(TypeInfo type, Class<?>... classes) { if (type instanceof ParameterizedTypeInfo) { String rawClassName = type.getRaw().getName(); for (Class<?> c : classes) { if (rawClassName.equals(c.getName())) { return true; } } } return false; }
public List<TypeInfo> classes(Collection<TypeInfo> classTypeInfos) { return classTypeInfos .stream() .filter(clazz -> ((ApiTypeInfo)clazz.getRaw()).isConcrete()) .collect(Collectors.toList()); }
public static boolean isParentConcrete(Collection<TypeInfo> superTypes) { for (TypeInfo stype : superTypes) { if (((ApiTypeInfo)stype.getRaw()).isConcrete()) { return true; } } return false; }
public List<TypeInfo> abstractClasses(Collection<TypeInfo> classTypeInfos) { return classTypeInfos .stream() .filter(clazz -> !((ApiTypeInfo)clazz.getRaw()).isConcrete()) .collect(Collectors.toList()); } }
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; }
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>"; }
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; } }
@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; }
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 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(); }
@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(); }
private void addImport(ClassTypeInfo currentType, Set<String> imports, TypeInfo type) { ClassKind typeKind = type.getKind(); if (type.isVariable() || typeKind.basic) { return; } if (!typeKind.collection && typeKind != ClassKind.THROWABLE && !type.equals(currentType) && !type.getRaw().getPackageName().startsWith("java.lang")) { imports.add(type.getRaw().getPackageName() + "." + type.getRaw().getSimpleName()); } if (type instanceof ParameterizedTypeInfo) { for (TypeInfo arg : ((ParameterizedTypeInfo) type).getArgs()) { addImport(currentType, imports, arg); } } }
protected boolean isLegalContainerParam(TypeInfo type) { TypeInfo raw = type.getRaw(); if (raw.getName().equals(List.class.getName()) || raw.getName().equals(Set.class.getName())) { TypeInfo argument = ((ParameterizedTypeInfo) type).getArgs().get(0); if (argument.getKind().basic || argument.getKind().json || argument.getKind() == ClassKind.DATA_OBJECT) { return true; } } else if (raw.getName().equals(Map.class.getName())) { TypeInfo argument0 = ((ParameterizedTypeInfo) type).getArgs().get(0); if (!argument0.getName().equals(String.class.getName())) { return false; } TypeInfo argument1 = ((ParameterizedTypeInfo) type).getArgs().get(1); if (argument1.getKind().basic || argument1.getKind().json) { return true; } } return false; } }
ClassTypeInfo ct = type.getRaw();
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(); } } }
@Override public String resolveTypeLink(TypeElement elt, Coordinate coordinate) { TypeInfo type = null; try { type = factory.create(elt.asType()); } catch (Exception e) { System.out.println("Could not resolve doc link for type " + elt.getQualifiedName()); return null; } if (type.getKind().equals(ClassKind.ENUM) && ((EnumTypeInfo)type).isGen()) { String baselink = null; if (coordinate == null) baselink = "../"; else baselink = "../../" + coordinate.getArtifactId() + "/"; return baselink + "enums.html#" + elt.getSimpleName().toString(); } if (type.getKind().equals(ClassKind.DATA_OBJECT)) { String baselink = null; if (coordinate == null) baselink = "../"; else baselink = "../../" + coordinate.getArtifactId() + "/"; return baselink + "dataobjects.html#" + elt.getSimpleName().toString(); } if (type.getKind().equals(ClassKind.API)) { ApiTypeInfo api = (ApiTypeInfo)type.getRaw(); return "../../scaladocs/" + api.translateName("scala").replace('.', '/') + ".html"; } return null; }
private String renderLinkToHtml(Tag.Link link) { ClassTypeInfo rawType = link.getTargetType().getRaw(); if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == DATA_OBJECT) { return "{@link " + rawType.getName() + "}"; } else { if (rawType.getKind() == ClassKind.API) { Element elt = link.getTargetElement(); String eltKind = elt.getKind().name(); String ret = "{@link " + rawType.translateName(id); if ("METHOD".equals(eltKind)) { /* todo find a way for translating the complete signature */ ret += "#" + elt.getSimpleName().toString(); } if (label.length() > 0) { ret += " " + label; } ret += "}"; return ret; } } } return "{@link " + rawType.getName() + "}"; } }
private String renderLinkToHtml(Tag.Link link) { ClassTypeInfo rawType = link.getTargetType().getRaw(); if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == DATA_OBJECT) { return "{@link " + rawType.getName() + "}"; } else { if (rawType.getKind() == ClassKind.API) { Element elt = link.getTargetElement(); String eltKind = elt.getKind().name(); String ret = "{@link " + rawType.translateName(id); if ("METHOD".equals(eltKind)) { /* todo find a way for translating the complete signature */ ret += "#" + elt.getSimpleName().toString(); } if (label.length() > 0) { ret += " " + label; } ret += "}"; return ret; } } } return "{@link " + rawType.getName() + "}"; } }
public static String renderLinkToHtml(Tag.Link link) { ClassTypeInfo rawType = link.getTargetType().getRaw(); if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == ClassKind.DATA_OBJECT) { return "[" + rawType.getName() + "]"; } else { if (rawType.getKind() == ClassKind.API) { String ret = "[" + rawType.getName() + "]"; if (label.length() > 0) { ret += "[" + label + "]" + ret; } return ret; } } } return "[" + rawType.getName() + "]"; } }
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); }