@Override protected void checkMethod(MethodInfo methodInfo) { // We don't allow overloaded methods in proxies List<MethodInfo> methodsByName = methodMap.get(methodInfo.getName()); if (methodsByName != null) { throw new GenException(this.modelElt, "Overloaded methods are not allowed in ProxyGen interfaces " + methodInfo.getName()); } }
/** * Some method names require special treatment when used in lang-scala. e.g. we have to convert the name * of methods where the original version gets replaced with one returning a scala.Future. */ public static String createNameForMethodReturningAFuture(MethodInfo method) { String methodName = method.getName(); if (methodName.endsWith("Handler")) { methodName = methodName.substring(0, methodName.length()-7); } methodName += "Future"; return escapeIfKeyword(methodName); }
public static boolean isMethodNeedsOverride(String callingClassName, MethodInfo method) { if (method.getName().equals("toString") && method.getParams().isEmpty()) { return true; } else { /*There is only one entry in here (0 would be a bug)*/ for (ClassTypeInfo ownerType : method.getOwnerTypes()) { if (!ownerType.getName().equals(callingClassName)) { return true; } } return false; } }
@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(); }
protected void checkMethod(MethodInfo methodInfo) { List<MethodInfo> methodsByName = methodMap.get(methodInfo.getName()); if (methodsByName != null) { // Overloaded methods must have same return type for (MethodInfo meth: methodsByName) { if (!meth.isContainingAnyJavaType() && !meth.getReturnType().equals(methodInfo.getReturnType())) { throw new GenException(this.modelElt, "Overloaded method " + methodInfo.getName() + " must have the same return type " + meth.getReturnType() + " != " + methodInfo.getReturnType()); } } } }
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()); }
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 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" : ""); } } }
writer.format("j_%s", ifaceName); writer.format("[\"%s(", method.getName()); boolean first = true; for (ParamInfo param : method.getParams()) {
ret = new StringBuilder("delegate"); ret.append(".").append(method.getName()).append("("); int index = 0; for (ParamInfo param : method.getParams()) {
@Test public void testValidTypeParam() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithTypeParameter.class); assertEquals(1, model.getMethods().size()); MethodInfo mi = model.getMethods().get(0); assertEquals("foo", mi.getName()); assertEquals(Arrays.asList("T"), mi.getTypeParams().stream().map(TypeParamInfo::getName).collect(Collectors.toList())); }
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 + ")"; }
@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()); }
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"); } } }
@Override protected void genMethodAdapter(ClassModel model, MethodInfo method, CodeWriter writer) { if (method.getReturnType().getKind() != VOID) { if (method.isFluent()) { writer.format("%s ;\n", genMethodCall(model, method)); writer.format("return %s;\n", method.isStaticMethod() ? model.getType().getSimpleName() : "that"); } else if (method.isCacheReturn()) { writer .format("if (that.cached%s == null) {\n", method.getName()) .indent() .format("that.cached%s = %s;\n", method.getName(), convReturn(model, method, method.getReturnType(), genMethodCall(model, method))) .unindent() .append("}\n") .format("return that.cached%s;\n", method.getName()); } else { writer.format("return %s ;\n", convReturn(model, method, method.getReturnType(), genMethodCall(model, method))); } } else { writer.format("%s;\n", genMethodCall(model, method)); } }
void checkMethod(MethodInfo meth, String name, int numParams, String returnType, MethodKind kind, Doc comment, MethodCheck... checks) { EnumSet<MethodCheck> checkSet = EnumSet.noneOf(MethodCheck.class); Collections.addAll(checkSet, checks); assertEquals(name, meth.getName()); if (comment != null) { assertNotNull(meth.getComment()); assertEquals(comment.getFirstSentence(), meth.getDoc().getFirstSentence()); assertEquals(comment.getBody(), meth.getDoc().getBody()); assertEquals(comment.getBlockTags(), meth.getDoc().getBlockTags()); } else { assertNull(meth.getComment()); } assertEquals(kind, meth.getKind()); assertEquals(returnType, meth.getReturnType().toString()); assertEquals(checkSet.contains(MethodCheck.CACHE_RETURN), meth.isCacheReturn()); assertEquals(checkSet.contains(MethodCheck.FLUENT), meth.isFluent()); assertEquals(checkSet.contains(MethodCheck.STATIC), meth.isStaticMethod()); assertEquals(numParams, meth.getParams().size()); }