/** * @return the @{link #getName} value of this type */ public String toString() { return getName(); }
public String translateName(TypeNameTranslator translator) { return getName(); }
public static String fromObjectToInstanceOf(TypeInfo type, Collection<TypeParamInfo> typeParams, Collection<? extends TypeParamInfo> methodTypeParams) { String ret = ""; if (type.getName().equals("io.vertx.core.Future") && !type.isParameterized()) { if (typeParams.isEmpty() && methodTypeParams.isEmpty()) ret += ".asInstanceOf[JFuture[_]]"; else ret += ".asInstanceOf[JFuture[Object]]"; } else { ret += ".asInstanceOf[" + toJavaType(type, true) + "]"; } return ret; }
protected boolean isLegalDataObjectTypeReturn(TypeInfo type) { if (type.getKind() == ClassKind.DATA_OBJECT) { TypeElement typeElt = elementUtils.getTypeElement(type.getName()); if (typeElt != null) { Optional<ExecutableElement> opt = elementUtils. getAllMembers(typeElt). stream(). flatMap(Helper.FILTER_METHOD). filter(m -> m.getSimpleName().toString().equals("toJson") && m.getParameters().isEmpty() && m.getReturnType().toString().equals(JSON_OBJECT)). findFirst(); return opt.isPresent(); } } return false; }
@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(); } }
@Override public String toString() { StringBuilder sb = new StringBuilder(); if (typeParams.size() > 0) { for (int i = 0;i < typeParams.size();i++) { sb.append(i > 0 ? ", " : "<"); sb.append(typeParams.get(i).getName()); } sb.append("> "); } sb.append(returnType.getName()); sb.append(' '); sb.append(getSignature().toString()); return sb.toString(); } }
@Override public String filename(Model model) { if(!((TypeInfo)model.getVars().get("type")).getName().equals("io.vertx.ext.web.handler.sockjs.PermittedOptions")) { return "scala/" + model.getModule().translateQualifiedName(model.getFqn(), "scala").replace('.', '/') + ".scala"; } return null; }
@Override public String filename(Model model) { if(!((TypeInfo)model.getVars().get("type")).getName().equals("io.vertx.core.buffer.Buffer")) { return "scala/" + model.getModule().translateQualifiedName(model.getFqn(), "scala").replace('.', '/') + ".scala"; } return null; }
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; } }
public static Set<String> generateImports(TypeInfo type, Collection<TypeInfo> imps, List<MethodInfo> methods) { Set<String> ret = new java.util.HashSet<>(); ret.add(convertTypeToAliasedType(type)); for (TypeInfo imported : imps) { /*Don't import implementations*/ if (!imported.getName().contains(".impl.")) { importForType(Helper.getPackageName(type.getName()), imported, ret); } } for (MethodInfo method : methods) { for (ParamInfo param : method.getParams()) { importForType(Helper.getPackageName(type.getName()), param.getType(), ret); } } return ret; }
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(); }
public static boolean doesTypeRequireConversion(TypeInfo type){ return type.getKind() != ClassKind.JSON_OBJECT && type.getKind() != ClassKind.JSON_ARRAY && type.getKind() != ClassKind.ENUM && !type.getName().equals("io.vertx.core.buffer.Buffer"); }
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); }); }
private void generateImport(DataObjectModel model, CodeWriter writer) { writer.println("import " + model.getType().getRaw().getName()); Set<String> genImports = new TreeSet<>(); for (PropertyInfo p : model.getPropertyMap().values()) { ClassKind propertyKind = p.getType().getKind(); if ((propertyKind == ClassKind.ENUM || propertyKind == ClassKind.DATA_OBJECT) && !p.getType().equals(model.getType())) { genImports.add(p.getType().getName()); } } for (String i : genImports) { writer.println("import " + i); } }
/** * 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())+"}"; }
void checkParam(ParamInfo param, String name, Type expectedType, Type expectedUnresolvedType) { checkParam(param, name ,expectedType); TypeInfo expectedUnresolvedTypeInfo = TypeReflectionFactory.create(expectedUnresolvedType); assertEquals(expectedUnresolvedTypeInfo.getName(), param.getUnresolvedType().getName()); assertEquals(expectedUnresolvedTypeInfo.getKind(), param.getUnresolvedType().getKind()); }
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()); }
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()); } }
@Test public void testReadStreamWithParameterizedTypeArg() throws Exception { ClassModel model = new GeneratorHelper().generateClass(ReadStreamWithParameterizedTypeArg.class); ApiTypeInfo apiType = (ApiTypeInfo) model.getType().getRaw(); assertTrue(apiType.isReadStream()); ParameterizedTypeInfo readStreamArg = (ParameterizedTypeInfo) apiType.getReadStreamArg(); assertEquals(TypeReflectionFactory.create(List.class), readStreamArg.getRaw()); assertEquals(1, readStreamArg.getArgs().size()); assertEquals("T", readStreamArg.getArgs().get(0).getName()); assertFalse(apiType.isWriteStream()); assertNull(apiType.getWriteStreamArg()); assertFalse(apiType.isHandler()); }