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(); }
private boolean isLegalClassTypeParam(ExecutableElement elt, TypeInfo type) { if (type.getKind() == ClassKind.CLASS_TYPE && type.isParameterized()) { ParameterizedTypeInfo parameterized = (ParameterizedTypeInfo) type; TypeInfo arg = parameterized.getArg(0); if (arg.isVariable()) { TypeVariableInfo variable = (TypeVariableInfo) arg; for (TypeParameterElement typeParamElt : elt.getTypeParameters()) { if (typeParamElt.getSimpleName().toString().equals(variable.getName())) { return true; } } } } return false; }
private boolean isVertxGenInterface(TypeInfo type, boolean allowParameterized) { if (type.getKind() == ClassKind.API) { if (type.isParameterized()) { if (allowParameterized) { ParameterizedTypeInfo parameterized = (ParameterizedTypeInfo) type; for (TypeInfo paramType : parameterized.getArgs()) { ClassKind kind = paramType.getKind(); if (!(paramType instanceof ApiTypeInfo || paramType.isVariable() || kind == ClassKind.VOID || kind.basic || kind.json || kind == ClassKind.DATA_OBJECT || kind == ClassKind.ENUM )) { return false; } if (paramType.isNullable()) { return false; } } return true; } else { return false; } } else { return true; } } return false; }
/** * @return true when the param is nullable */ public boolean isNullable() { return type.getKind() == ClassKind.OBJECT || type.isNullable(); }
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(); } }
boolean nullable = type.isNullable(); if (type.getKind().basic) { String ret = name + ".asInstanceOf[" + toJavaType(type, false) + "]"; if (nullable) { } else if (type.getKind() == ClassKind.THROWABLE) { String ret = name; if (nullable) { } else if (type.getKind() == ClassKind.OBJECT) { String ret = name; if (type.isVariable()) { if (nullable) { ret = name + ".map(x => toJava["+type.getSimpleName()+"](x)).orNull"; } else { ret = "toJava["+type.getSimpleName()+"](" + name + ")"; } else if (type.getKind() == ClassKind.CLASS_TYPE) { String ret = "toJavaClass("+name+")"; if (nullable) { } else if (type.getKind() == ClassKind.VOID || type.getName().equals("java.lang.Void") || type.getName().equals("void")) { return name; } else if (type.getKind() == ClassKind.JSON_OBJECT || type.getKind() == ClassKind.JSON_ARRAY || type.getKind() == ClassKind.ENUM || type.getName().equals("io.vertx.core.buffer.Buffer")) {
public String generateHandler(ParamInfo param) { TypeInfo typeArg = ((ParameterizedTypeInfo)((ParameterizedTypeInfo)param.getType()).getArg(0)).getArg(0); if (typeArg.getKind() == ClassKind.LIST || typeArg.getKind() == ClassKind.SET) { String coll = typeArg.getKind() == ClassKind.LIST ? "List" : "Set"; TypeInfo innerTypeArg = ((ParameterizedTypeInfo)typeArg).getArg(0); if (innerTypeArg.getName().equals("java.lang.Character")) return "HelperUtils.create" + coll + "CharHandler(msg)"; if (innerTypeArg.getKind() == ClassKind.DATA_OBJECT) return "res -> {\n" + " if (res.failed()) {\n" + return "HelperUtils.create" + coll + "Handler(msg)"; if (typeArg.getKind() == ClassKind.DATA_OBJECT) return "res -> {\n" + " if (res.failed()) {\n" + " }\n" + " }"; if (typeArg.getKind() == ClassKind.API && ((ApiTypeInfo)typeArg).isProxyGen()) return "res -> {\n" + " if (res.failed()) {\n" + " } 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" +
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.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)); if (method.getReturnType().getKind() == PRIMITIVE) { cachedType = ((PrimitiveTypeInfo) returnType).getBoxed().getName(); } else {
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; } }
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); } } }
switch (type.getKind()) { case STRING: return "string"; case PRIMITIVE: case BOXED_PRIMITIVE: switch (type.getSimpleName()) { case "boolean": case "Boolean": return "Array"; case API: return type.getRaw().getSimpleName(); case MAP:
private boolean isLegalArgumentContainerReturn(TypeInfo argument, boolean allowAnyJavaType) { ClassKind argumentKind = argument.getKind(); return argumentKind.basic || argumentKind.json || argumentKind == ClassKind.OBJECT || (allowAnyJavaType && argumentKind == ClassKind.OTHER); }
TypeInfo declaringType = typeFactory.create(declaringElt.asType()); if (!declaringElt.equals(modelElt) && (declaringType.getKind() != ClassKind.API && declaringType.getKind() != ClassKind.HANDLER)) { return null; ClassTypeInfo type = typeFactory.create(declaringElt.asType()).getRaw(); forEach(overridenMethodElt -> { modelMethods.add(overridenMethodElt); ownerTypes.add(typeFactory.create((DeclaredType) ancestorElt.asType()).getRaw()); }); throw genEx; returnType.collectImports(collectedTypes); if (isCacheReturn && returnType.isVoid()) { throw new GenException(modelMethod, "void method can't be marked with @CacheReturn"); } else if (returnType.isNullable()) { throw new GenException(modelMethod, "Fluent return type cannot be nullable"); if (!declaringElt.equals(modelElt) && declaringType.getKind() == ClassKind.API) { ApiTypeInfo declaringApiType = (ApiTypeInfo) declaringType.getRaw(); if (declaringApiType.isConcrete()) { if (typeUtils.isSameType(methodType, modelMethod.asType())) {
if (type.isParameterized() && type.getRaw().getName().equals("rx.Observable")) { String adapterFunction; ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo) type; if (parameterizedType.getArg(0).isVariable()) { adapterFunction = "java.util.function.Function.identity()"; } else { adapterFunction = "obj -> (" + parameterizedType.getArg(0).getRaw().getName() + ")obj.getDelegate()"; } else if (type.isParameterized() && (type.getRaw().getName().equals("io.reactivex.Flowable") || type.getRaw().getName().equals("io.reactivex.Observable"))) { String adapterFunction; ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo) type; if (parameterizedType.getArg(0).isVariable()) { adapterFunction = "java.util.function.Function.identity()"; } else { adapterFunction = "obj -> (" + parameterizedType.getArg(0).getRaw().getName() + ")obj.getDelegate()";
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 invokeMethod(String target, TypeInfo type, MethodInfo method, Collection<TypeParamInfo> typeParams) { if (method.getReturnType().getKind() == ClassKind.OBJECT) { String ret = "toScala[" + method.getReturnType().getName() + "](" + invokeMethodWithoutConvertingReturn(target, type, method, typeParams) + ")"; if (method.getReturnType().isNullable()) return "scala.Option(" + ret + ")"; return ret; } else { return toScalaWithConversion(invokeMethodWithoutConvertingReturn(target, type, method, typeParams), method.getReturnType(), typeParams, method.getTypeParams()); } }
/** * @return the @{link #getName} value of this type */ public String toString() { return getName(); }