private boolean isLegalArgumentContainerReturn(TypeInfo argument, boolean allowAnyJavaType) { ClassKind argumentKind = argument.getKind(); return argumentKind.basic || argumentKind.json || argumentKind == ClassKind.OBJECT || (allowAnyJavaType && argumentKind == ClassKind.OTHER); }
private boolean isLegalDataObjectTypeParam(TypeInfo type) { if (type.getKind() == ClassKind.DATA_OBJECT) { DataObjectTypeInfo classType = (DataObjectTypeInfo) type; return !classType.isAbstract(); } return false; }
private boolean isLegalCallbackValueType(TypeInfo type, boolean allowAnyJavaType) { if (type.getKind() == ClassKind.VOID) { return true; } return isLegalNonCallableReturnType(type, allowAnyJavaType); }
private boolean isLegalArgumentContainerParam(TypeInfo argument, boolean allowAnyJavaType) { ClassKind argumentKind = argument.getKind(); return argumentKind.basic || argumentKind.json || isVertxGenInterface(argument, false) || argumentKind == ClassKind.OBJECT || (allowAnyJavaType && argumentKind == ClassKind.OTHER); }
/** * @return true when the param is nullable */ public boolean isNullable() { return type.getKind() == ClassKind.OBJECT || type.isNullable(); }
@Override public String resolveLabel(Element elt, String defaultLabel) { if (elt.getKind().equals(ElementKind.METHOD)) { TypeInfo type = factory.create(elt.getEnclosingElement().asType()); if (type.getKind().equals(ClassKind.DATA_OBJECT)) { String name = elt.getSimpleName().toString(); if (name.startsWith("set") && name.length() > 3 && Character.isUpperCase(name.charAt(3))) name = java.beans.Introspector.decapitalize(name.substring(3)); return name; } } return defaultLabel; } }
private boolean isLegalHandlerType(TypeInfo type, boolean allowAnyJavaType) { if (type.getErased().getKind() == ClassKind.HANDLER) { TypeInfo eventType = ((ParameterizedTypeInfo) type).getArgs().get(0); if (isLegalCallbackValueType(eventType, allowAnyJavaType) || eventType.getKind() == ClassKind.THROWABLE) { return true; } } return false; }
private boolean isLegalFunctionType(TypeInfo typeInfo, boolean allowAnyJavaType) { if (typeInfo.getErased().getKind() == ClassKind.FUNCTION) { TypeInfo paramType = ((ParameterizedTypeInfo) typeInfo).getArgs().get(0); if (isLegalCallbackValueType(paramType, allowAnyJavaType) || paramType.getKind() == ClassKind.THROWABLE) { TypeInfo returnType = ((ParameterizedTypeInfo) typeInfo).getArgs().get(1); return isLegalNonCallableParam(returnType, allowAnyJavaType); } } return false; }
private static boolean containsAnyJavaType(TypeInfo type) { if (type instanceof ParameterizedTypeInfo) { return containsAnyJavaType(type.getRaw()) || ((ParameterizedTypeInfo) type).getArgs().stream().anyMatch(MethodInfo::containsAnyJavaType); } else { return type.getKind() == ClassKind.OTHER; } }
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; }
public static boolean shouldMethodReturnAFuture(MethodInfo method) { int size = method.getParams().size(); return size > 0 && isLastParamAsyncResultHandler(method) && !(method.getReturnType().getKind() == ClassKind.HANDLER); }
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(); } }
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(); } }
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); }); }
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()); }
@Test public void testValidHandlerReturn() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithHandlerReturn.class); assertEquals(MethodWithHandlerReturn.class.getName(), model.getIfaceFQCN()); assertEquals(MethodWithHandlerReturn.class.getSimpleName(), model.getIfaceSimpleName()); assertTrue(model.getReferencedTypes().isEmpty()); assertTrue(model.getSuperTypes().isEmpty()); assertEquals(1, model.getMethods().size()); checkMethod(model.getMethods().get(0), "methodWithHandlerStringReturn", 0, new TypeLiteral<Handler<String>>() {}, MethodKind.OTHER); TypeInfo returnType = model.getMethods().get(0).getReturnType(); assertEquals(ClassKind.HANDLER, returnType.getKind()); assertEquals(ClassKind.STRING, ((ParameterizedTypeInfo)returnType).getArg(0).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()); } }