@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(); } }
public static boolean isLastParamAsyncResultHandler(MethodInfo method) { int size = method.getParams().size(); return isAsyncResultHandler(method.getParam(size-1).getType()); }
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 + ")"; }
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()); }
public static TypeInfo typeOfReturnedFuture(MethodInfo method) { return ((ParameterizedTypeInfo)((ParameterizedTypeInfo)method.getParam(method.getParams().size()-1).getType()).getArg(0)).getArg(0); }
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 invokeMethodAndUseProvidedHandler(String target, TypeInfo type, MethodInfo method, Collection<TypeParamInfo> typeParams, String handler) { String typeParamString = assembleTypeParamString(method); String paramString = ""; for (ParamInfo param : method.getParams()) { if (!paramString.equals("")) { paramString += ", "; } if (isAsyncResultHandler(param.getType())) { paramString += handler; } else { paramString += toJavaWithConversion(escapeIfKeyword(param.getName()), param.getType(), typeParams, method.getTypeParams()); } } return target + "." + escapeIfKeyword(method.getName()) + typeParamString + "(" + paramString + ")"; }
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; }
@Test public void testMethodWithHandlerNullable() throws Exception { for (Class<?> clazz : Arrays.asList( MethodWithHandlerNullable.class, MethodWithNullableTypeVariableHandler.class, MethodWithHandlerNullableVoid.class)) { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi1 = methods.get(0); assertTrue(((ParameterizedTypeInfo) mi1.getParams().get(0).getType()).getArg(0).isNullable()); }, clazz); } }
@Test public void testMethodWithNullableInheritedParams() throws Exception { Consumer<ClassModel> check = model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi2 = methods.get(0); assertTrue(mi2.getParams().get(0).getType().isNullable()); assertTrue(((ParameterizedTypeInfo) mi2.getParams().get(1).getType()).getArg(0).isNullable()); assertTrue(((ParameterizedTypeInfo) ((ParameterizedTypeInfo) mi2.getParams().get(2).getType()).getArg(0)).getArg(0).isNullable()); }; generateClass(check, MethodWithNullableInheritedParams.class, MethodWithNullableParams.class); generateClass(check, MethodWithNullableInheritedParams.class); }
@Test public void testValidVoidTypeArg() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidVoidTypeArg.class); assertEquals(1, model.getMethods().size()); MethodInfo mi = model.getMethods().get(0); assertEquals("foo", mi.getName()); assertEquals(new ParameterizedTypeInfo(new ClassTypeInfo(ClassKind.API, GenericInterface.class.getName(), null, false, Collections.emptyList()), false, Arrays.asList(TypeReflectionFactory.create(Void.class))), mi.getParams().get(0).getType()); ParameterizedTypeInfo genericType = (ParameterizedTypeInfo) mi.getParams().get(0).getType(); ClassTypeInfo voidType = (ClassTypeInfo) genericType.getArgs().get(0); assertEquals(ClassKind.VOID, voidType.getKind()); }
@Test public void testInterfaceWithListNullableParamOverride() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi2 = methods.get(0); assertTrue(((ParameterizedTypeInfo) mi2.getParams().get(0).getType()).getArg(0).isNullable()); }, MethodWithListNullableParamOverride.class, MethodWithListNullableParam.class); }
@Test public void testValidCloseWithFuture() throws Exception { ProxyModel model = generateProxyModel(ValidProxyCloseWithFuture.class); assertEquals(1, model.getMethods().size()); assertEquals(MethodKind.FUTURE, model.getMethods().get(0).getKind()); ParameterizedTypeInfo handlerType = (ParameterizedTypeInfo) model.getMethods().get(0).getParams().get(0).getType(); ParameterizedTypeInfo asyncResultType = (ParameterizedTypeInfo) handlerType.getArgs().get(0); assertEquals(ClassKind.VOID, asyncResultType.getArgs().get(0).getKind()); }
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" : ""); } } }
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()); }
@Test public void testValidEnumParam() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithEnumParam.class); assertEquals(MethodWithEnumParam.class.getName(), model.getIfaceFQCN()); assertEquals(MethodWithEnumParam.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getImportedTypes().contains(TypeReflectionFactory.create(TestEnum.class))); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); assertEquals(2, model.getMethods().size()); MethodInfo method = model.getMethods().get(0); checkMethod(method, "methodWithEnumParam", 1, "void", MethodKind.OTHER); List<ParamInfo> params = method.getParams(); checkParam(params.get(0), "weirdo", TestEnum.class); EnumTypeInfo enumType = (EnumTypeInfo) params.get(0).getType(); assertFalse(enumType.isGen()); assertEquals(Arrays.asList("TIM", "JULIEN", "NICK", "WESTON"), enumType.getValues()); method = model.getMethods().get(1); checkMethod(method, "methodWithGenEnumParam", 1, "void", MethodKind.OTHER); params = method.getParams(); checkParam(params.get(0), "weirdo", TestGenEnum.class); enumType = (EnumTypeInfo) params.get(0).getType(); assertTrue(enumType.isGen()); assertEquals(Arrays.asList("LAURA", "BOB", "MIKE", "LELAND"), enumType.getValues()); }
@Test public void testMethodWithOverloadedNullableParam() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); MethodInfo mi1 = methods.get(0); checkMethod(mi1, "method", 2, "void", MethodKind.OTHER); assertEquals(ClassKind.STRING, mi1.getParams().get(0).getType().getKind()); checkParam(mi1.getParams().get(0), "s", String.class); assertTrue(mi1.getParams().get(0).isNullable()); checkParam(mi1.getParams().get(1), "i", Integer.class); assertFalse(mi1.getParams().get(1).isNullable()); MethodInfo mi2 = methods.get(1); checkMethod(mi2, "method", 2, "void", MethodKind.OTHER); checkParam(mi2.getParams().get(0), "i", Integer.class); assertFalse(mi2.getParams().get(0).isNullable()); checkParam(mi2.getParams().get(1), "s", String.class); assertTrue(mi2.getParams().get(1).isNullable()); }, MethodWithOverloadedNullableParam.class); }
@Test public void testValidClassTypeParams() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidClassTypeParams.class); List<MethodInfo> methods = model.getMethods(); assertEquals(2, methods.size()); MethodInfo methodParam = methods.get(0); checkMethod(methodParam, "methodParam", 2, "void", MethodKind.OTHER); ParamInfo resolved = methodParam.resolveClassTypeParam((TypeVariableInfo) methodParam.getParam(0).getType()); assertSame(resolved, methodParam.getParam(1)); MethodInfo returnParam = methods.get(1); checkMethod(returnParam, "returnParam", 1, "T", MethodKind.OTHER); resolved = methodParam.resolveClassTypeParam((TypeVariableInfo) returnParam.getReturnType()); assertSame(resolved, methodParam.getParam(1)); }
@Test public void testMethodWithTypeVarParamByGenericType() throws Exception { Runnable test = () -> { try { ClassModel model = new GeneratorHelper().generateClass(MethodWithTypeVarParamByGenericType.class); MethodInfo meth = model.getMethods().get(0); ParamInfo param = meth.getParam(0); ParameterizedTypeInfo handler = (ParameterizedTypeInfo) param.getType(); assertEquals(Handler.class.getName(), handler.getRaw().getName()); ParameterizedTypeInfo genericInt2 = (ParameterizedTypeInfo) handler.getArg(0); assertEquals(GenericInterface2.class.getName(), genericInt2.getRaw().getName()); TypeVariableInfo k = (TypeVariableInfo) genericInt2.getArg(0); assertEquals("K", k.getName()); TypeVariableInfo v = (TypeVariableInfo) genericInt2.getArg(1); assertEquals("V", v.getName()); } catch (Exception e) { throw new AssertionError(e); } }; blacklist(test, Stream.of(WriteStream.class)); test.run(); }