/** * @return true if the method has a nullable return */ public boolean isNullableReturn() { return returnType.isNullable(); }
/** * @return true when the param is nullable */ public boolean isNullable() { return type.getKind() == ClassKind.OBJECT || type.isNullable(); }
/** * @return true when the param callback value is nullable: when the parameter type is an * handler or an async result handler it returns the nullable boolean of the corresponding * parameter, otherwise it returns null */ public Boolean isNullableCallback() { switch (type.getKind()) { case HANDLER: TypeInfo handler = ((ParameterizedTypeInfo)type).getArg(0); switch (handler.getKind()) { case ASYNC_RESULT: TypeInfo asyncResult = ((ParameterizedTypeInfo)handler).getArg(0); return asyncResult.isNullable(); default: return handler.isNullable(); } default: return null; } }
private boolean isLegalHandlerAsyncResultType(TypeInfo type, boolean allowAnyJavaType) { if (type.getErased().getKind() == ClassKind.HANDLER) { TypeInfo eventType = ((ParameterizedTypeInfo) type).getArgs().get(0); if (eventType.getErased().getKind() == ClassKind.ASYNC_RESULT && !eventType.isNullable()) { TypeInfo resultType = ((ParameterizedTypeInfo) eventType).getArgs().get(0); if (isLegalCallbackValueType(resultType, allowAnyJavaType)) { return true; } } } return false; }
} else if (returnType.isNullable()) { throw new GenException(modelMethod, "Fluent return type cannot be nullable");
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; }
@Test public void testInterfaceWithNullableReturnOverride() throws Exception { generateClass(model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi3 = methods.get(0); assertTrue(mi3.getReturnType().isNullable()); }, InterfaceWithNullableReturnOverride.class, InterfaceWithNullableReturnMethod.class); }
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" : ""); } } }
@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 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 testMethodWithCovariantNullableReturn() throws Exception { Consumer<ClassModel> check = model -> { List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); MethodInfo mi2 = methods.get(0); assertTrue(mi2.getReturnType().isNullable()); }; generateClass(check, MethodWithCovariantNullableReturn.class, MethodWithNullableReturn.class); generateClass(check, MethodWithCovariantNullableReturn.class); }
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); }
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()); } }
boolean nullable = type.isNullable(); ClassKind kind = type.getKind(); String typeName = type.getName();
assertFalse("Expects " + m.getName() + " to have nullable return type", m.isNullableReturn()); List<TypeInfo> args = ((ParameterizedTypeInfo) m.getReturnType()).getArgs(); assertTrue("Expects " + m.getName() + " to have nullable return type", args.get(args.size() - 1).isNullable()); });
boolean nullable = type.isNullable(); ClassKind kind = type.getKind(); if (kind.basic) { ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String conversion = ".asScala"; if(parameterizedType.getArg(0).isNullable() && !doesTypeRequireConversion(parameterizedType.getArg(0))) { conversion += ".map(Option(_))"; ParameterizedTypeInfo parameterizedType = (ParameterizedTypeInfo)type; String conversion = ".asScala"; if(parameterizedType.getArg(0).isNullable() && !doesTypeRequireConversion(parameterizedType.getArg(0))) { conversion += ".map(Option(_))"; if(parameterizedType.getArg(1).isNullable() && !doesTypeRequireConversion(parameterizedType.getArg(1))) { conversion += ".mapValues(Option(_))";
boolean nullable = type.isNullable(); if (type.getKind().basic) { String ret = name + ".asInstanceOf[" + toJavaType(type, false) + "]"; if(parameterizedType.getArg(0).isNullable() && !doesTypeRequireConversion(parameterizedType.getArg(0))) { ret += ".map{case Some(x) => x;case None => null}"; } else if(doesTypeRequireConversion(parameterizedType.getArg(0))) { if(parameterizedType.getArg(0).isNullable() && !doesTypeRequireConversion(parameterizedType.getArg(0))) { ret += ".map{case Some(x) => x;case None => null}"; } else if(doesTypeRequireConversion(parameterizedType.getArg(0))) { if(parameterizedType.getArg(1).isNullable() && !doesTypeRequireConversion(parameterizedType.getArg(1))) { ret += ".mapValues{case Some(x) => x;case None => null}"; } else if(doesTypeRequireConversion(parameterizedType.getArg(0))) {