public static String convertArgListToString(TypeInfo type, boolean convert, BiFunction<TypeInfo,Boolean,String> conversion) { if (type.isParameterized()) { String ret = String.join(", ", ((ParameterizedTypeInfo)type) .getArgs().stream() .map(arg -> conversion.apply(arg, convert)) .collect(Collectors.toList())); if (!ret.isEmpty()) { return "[" + ret + "]"; } } return ""; }
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; } }
public MethodKind getKind() { int lastParamIndex = params.size() - 1; if (lastParamIndex >= 0 && (returnType.isVoid() || fluent)) { TypeInfo lastParamType = params.get(lastParamIndex).type; if (lastParamType.getKind() == ClassKind.HANDLER) { TypeInfo typeArg = ((ParameterizedTypeInfo) lastParamType).getArgs().get(0); if (typeArg.getKind() == ClassKind.ASYNC_RESULT) { return MethodKind.FUTURE; } else { return MethodKind.HANDLER; } } } return MethodKind.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; }
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; } }
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 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; }
protected boolean isLegalContainerParam(TypeInfo type, boolean allowAnyJavaType) { // List<T> and Set<T> are also legal for params if T = basic type, json, @VertxGen, @DataObject // Map<K,V> is also legal for returns and params if K is a String and V is a basic type, json, or a @VertxGen interface if (rawTypeIs(type, List.class, Set.class, Map.class)) { TypeInfo argument = ((ParameterizedTypeInfo) type).getArgs().get(0); if (type.getKind() != ClassKind.MAP) { if (isLegalArgumentContainerParam(argument, allowAnyJavaType) || isLegalDataObjectTypeParam(argument) || argument.getKind() == ClassKind.ENUM) { return true; } } else if (argument.getKind() == ClassKind.STRING) { // Only allow Map's with String's for keys argument = ((ParameterizedTypeInfo) type).getArgs().get(1); return isLegalArgumentContainerParam(argument, allowAnyJavaType); } } return false; }
private boolean isLegalListSetMapResult(TypeInfo type) { if (type instanceof ParameterizedTypeInfo) { if (type.getKind() == ClassKind.LIST || type.getKind() == ClassKind.SET) { TypeInfo elementType = ((ParameterizedTypeInfo) type).getArgs().get(0); if (elementType.getKind().basic || elementType.getKind().json || elementType.getKind() == ClassKind.DATA_OBJECT) { return true; } } } return false; }
@Override protected MethodInfo createMethodInfo(Set<ClassTypeInfo> ownerTypes, String methodName, String comment, Doc doc, TypeInfo returnType, Text returnDescription, boolean isFluent, boolean isCacheReturn, List<ParamInfo> mParams, ExecutableElement methodElt, boolean isStatic, boolean isDefault, ArrayList<TypeParamInfo.Method> typeParams, TypeElement declaringElt, boolean methodDeprecated, Text methodDeprecatedDesc) { AnnotationMirror proxyIgnoreAnnotation = Helper.resolveMethodAnnotation(ProxyIgnore.class, elementUtils, typeUtils, declaringElt, methodElt); boolean isProxyIgnore = proxyIgnoreAnnotation != null; AnnotationMirror proxyCloseAnnotation = Helper.resolveMethodAnnotation(ProxyClose.class, elementUtils, typeUtils, declaringElt, methodElt); boolean isProxyClose = proxyCloseAnnotation != null; ProxyMethodInfo proxyMeth = new ProxyMethodInfo(ownerTypes, methodName, returnType, returnDescription, isFluent, isCacheReturn, mParams, comment, doc, isStatic, isDefault, typeParams, isProxyIgnore, isProxyClose, methodDeprecated, methodDeprecatedDesc); if (isProxyClose && mParams.size() > 0) { if (mParams.size() > 1) { throw new GenException(this.modelElt, "@ProxyClose methods can't have more than one parameter"); } if (proxyMeth.getKind() != MethodKind.FUTURE) { throw new GenException(this.modelElt, "@ProxyClose parameter must be Handler<AsyncResult<Void>>"); } TypeInfo type = mParams.get(0).getType(); TypeInfo arg = ((ParameterizedTypeInfo) ((ParameterizedTypeInfo) type).getArgs().get(0)).getArgs().get(0); if (arg.getKind() != ClassKind.VOID) { throw new GenException(this.modelElt, "@ProxyClose parameter must be " + "Handler<AsyncResult<Void>> instead of " + type); } } return proxyMeth; }
private String kotlinType(TypeInfo type) { if (type instanceof VoidTypeInfo) { return "Unit"; } else if (type instanceof PrimitiveTypeInfo) { return Case.CAMEL.format(Collections.singletonList(type.getSimpleName())); } else if (type.getKind() == ClassKind.BOXED_PRIMITIVE) { switch (type.getSimpleName()) { case "Integer": return "Int"; case "Character": return "Char"; default: return type.getSimpleName(); } } else if ("java.lang.Void".equals(type.getName())) { return "Unit"; } else if ("java.lang.Object".equals(type.getName())) { return "Any"; } else { if (type instanceof ParameterizedTypeInfo) { List<TypeInfo> args = ((ParameterizedTypeInfo) type).getArgs(); return type.getRaw().getSimpleName() + args.stream().map(this::kotlinType).collect(Collectors.joining(",", "<", ">")); } else { return type.getSimpleName(); } } }
protected boolean isLegalContainerReturn(TypeInfo type, boolean allowAnyJavaType) { if (rawTypeIs(type, List.class, Set.class, Map.class)) { List<TypeInfo> args = ((ParameterizedTypeInfo) type).getArgs(); if (type.getKind() == ClassKind.MAP) { if (args.get(0).getKind() != ClassKind.STRING) { return false; } TypeInfo valueType = args.get(1); return isLegalArgumentContainerReturn(valueType, allowAnyJavaType); } else { TypeInfo valueType = args.get(0); return isLegalArgumentContainerReturn(valueType, allowAnyJavaType) || valueType.getKind() == ClassKind.ENUM || isVertxGenInterface(valueType, false) || isLegalDataObjectTypeReturn(valueType); } } return false; }
private boolean isLegalHandlerAsyncResultType(TypeInfo type) { if (type.getErased().getKind() == ClassKind.HANDLER) { TypeInfo eventType = ((ParameterizedTypeInfo) type).getArgs().get(0); if (eventType.getErased().getKind() == ClassKind.ASYNC_RESULT) { TypeInfo resultType = ((ParameterizedTypeInfo) eventType).getArgs().get(0); if (resultType.getKind().json || resultType.getKind().basic || isLegalListSetMapResult(resultType) || resultType.getKind() == ClassKind.VOID || resultType.getKind() == ClassKind.ENUM || resultType.getKind() == ClassKind.DATA_OBJECT) { return true; } if (resultType.getKind() == ClassKind.API) { ApiTypeInfo cla = (ApiTypeInfo)resultType; if (cla.isProxyGen()) { return true; } } } } return false; }
private void addImport(ClassTypeInfo currentType, Set<String> imports, TypeInfo type) { ClassKind typeKind = type.getKind(); if (type.isVariable() || typeKind.basic) { return; } if (!typeKind.collection && typeKind != ClassKind.THROWABLE && !type.equals(currentType) && !type.getRaw().getPackageName().startsWith("java.lang")) { imports.add(type.getRaw().getPackageName() + "." + type.getRaw().getSimpleName()); } if (type instanceof ParameterizedTypeInfo) { for (TypeInfo arg : ((ParameterizedTypeInfo) type).getArgs()) { addImport(currentType, imports, arg); } } }
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 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()); }
@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 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()); }