@Override public ClassKind getKind() { return raw.getKind(); }
public TypeInfo getHandlerType() { return (type.getKind() == ClassKind.API) ? ((ApiTypeInfo)type).getHandlerArg() : null; }
private void processConstructor(ExecutableElement constrElt) { if (constrElt.getModifiers().contains(Modifier.PUBLIC)) { Element ownerElt = constrElt.getEnclosingElement(); if (ownerElt.equals(modelElt)) { List<? extends VariableElement> parameters = constrElt.getParameters(); int size = parameters.size(); if (size == 1) { TypeInfo ti = typeFactory.create(parameters.get(0).asType()); if (ti instanceof ClassTypeInfo) { ClassTypeInfo cl = (ClassTypeInfo) ti; if (cl.getKind() == ClassKind.JSON_OBJECT) { constructors |= 2; } } } else if (size == 0) { constructors |= 1; } } } }
protected void genRxImports(ClassModel model, PrintWriter writer) { for (ClassTypeInfo importedType : model.getImportedTypes()) { if (importedType.getKind() == ClassKind.API) { } else { if (!importedType.getPackageName().equals("java.lang")) { addImport(importedType, false, writer); } } } }
protected void genRxImports(ClassModel model, PrintWriter writer) { for (ClassTypeInfo importedType : model.getImportedTypes()) { if (importedType.getKind() == ClassKind.API) { } else { if (!importedType.getPackageName().equals("java.lang")) { addImport(importedType, false, writer); } } } }
public static String renderLinkToHtml(Tag.Link link) { ClassTypeInfo rawType = link.getTargetType().getRaw(); if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == ClassKind.DATA_OBJECT) { return "[" + rawType.getName() + "]"; } else { if (rawType.getKind() == ClassKind.API) { String ret = "[" + rawType.getName() + "]"; if (label.length() > 0) { ret += "[" + label + "]" + ret; } return ret; } } } return "[" + rawType.getName() + "]"; } }
private String renderLinkToHtml(Tag.Link link) { ClassTypeInfo rawType = link.getTargetType().getRaw(); if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == DATA_OBJECT) { return "{@link " + rawType.getName() + "}"; } else { if (rawType.getKind() == ClassKind.API) { Element elt = link.getTargetElement(); String eltKind = elt.getKind().name(); String ret = "{@link " + rawType.translateName(id); if ("METHOD".equals(eltKind)) { /* todo find a way for translating the complete signature */ ret += "#" + elt.getSimpleName().toString(); } if (label.length() > 0) { ret += " " + label; } ret += "}"; return ret; } } } return "{@link " + rawType.getName() + "}"; } }
private String renderLinkToHtml(Tag.Link link) { ClassTypeInfo rawType = link.getTargetType().getRaw(); if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == DATA_OBJECT) { return "{@link " + rawType.getName() + "}"; } else { if (rawType.getKind() == ClassKind.API) { Element elt = link.getTargetElement(); String eltKind = elt.getKind().name(); String ret = "{@link " + rawType.translateName(id); if ("METHOD".equals(eltKind)) { /* todo find a way for translating the complete signature */ ret += "#" + elt.getSimpleName().toString(); } if (label.length() > 0) { ret += " " + label; } ret += "}"; return ret; } } } return "{@link " + rawType.getName() + "}"; } }
if (rawType.getModule() != null) { String label = link.getLabel().trim(); if (rawType.getKind() == DATA_OBJECT) { if (label.length() == 0) { label = rawType.getSimpleName(); } else if (rawType.getKind() == ENUM && ((EnumTypeInfo) rawType).isGen()) { if (label.length() == 0) { label = rawType.getSimpleName();
private ClassTypeInfo assertClass(TypeInfo type, String expectedName, ClassKind expectedKind) { assertEquals(ClassTypeInfo.class, type.getClass()); ClassTypeInfo classType = (ClassTypeInfo) type; assertEquals(expectedKind, classType.getKind()); assertEquals(expectedName, classType.getName()); return classType; }
if (referencedType.getKind() == ClassKind.ENUM) { if (referencedType.getRaw().getModuleName().equals(model.getType().getRaw().getModuleName())) { writer.printf("import { %s } from './enums';\n", referencedType.getSimpleName()); if (referencedType.getKind() == ClassKind.DATA_OBJECT) { if (!referencedType.getRaw().getModuleName().equals(model.getType().getRaw().getModuleName())) { writer.printf("import { %s } from '%s/options';\n", referencedType.getSimpleName(), getNPMScope(referencedType.getRaw().getModule())); if (referencedType.getKind() == ClassKind.API) { if (referencedType.getRaw().getModuleName().equals(model.getType().getRaw().getModuleName())) { writer.printf("import { %s } from './index';\n", referencedType.getSimpleName());
@Test public void testValidExceptionParam() throws Exception { ClassModel model = new GeneratorHelper().generateClass(MethodWithValidThrowableParam.class); assertEquals(0, model.getReferencedTypes().size()); assertEquals(1, model.getImportedTypes().size()); assertEquals(ClassKind.THROWABLE, model.getImportedTypes().iterator().next().getKind()); assertEquals(1, model.getMethods().size()); String methodName = "methodWithThrowableParam"; MethodInfo method = model.getMethods().get(0); checkMethod(method, methodName, 1, "void", MethodKind.OTHER); List<ParamInfo> params = method.getParams(); checkParam(params.get(0), "t", Throwable.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 <R> void testInterfaceExtendingGenericInterface() throws Exception { ClassModel model = new GeneratorHelper().generateClass(InterfaceWithParameterizedDeclaredSupertype.class, GenericInterface.class); List<TypeInfo> superTypeArgs = model.getSuperTypeArguments(); assertEquals(1, superTypeArgs.size()); ClassTypeInfo superTypeArg = (ClassTypeInfo) superTypeArgs.get(0); assertEquals(ClassKind.STRING, superTypeArg.getKind()); List<MethodInfo> methods = model.getMethods(); assertEquals(1, methods.size()); checkMethod(methods.get(0), "methodWithClassTypeParam", 3, String.class, MethodKind.OTHER); checkParam(methods.get(0).getParam(0), "t", String.class); checkParam(methods.get(0).getParam(1), "handler", new TypeLiteral<Handler<String>>() {}); checkParam(methods.get(0).getParam(2), "asyncResultHandler", new TypeLiteral<Handler<AsyncResult<String>>>() {}); }
ClassTypeInfo col = (ClassTypeInfo) map.get(colType); int typeParamIndex = typeParamIndexes[idx]; assertEquals(colKind, col.getKind()); assertEquals(ClassTypeInfo.class, col.getClass()); assertEquals(colTypeParams.get(idx), col.getParams().stream().map(TypeParamInfo::getName).collect(Collectors.toList()));