public TypeInfo create(TypeMirror type) { return create(null, type); }
public TypeInfo create(DeclaredType type) { return create(null, type); }
@Override public String resolveLabel(Element elt, String defaultLabel) { if (elt.getKind() == ElementKind.METHOD) { TypeInfo type = factory.create(elt.getEnclosingElement().asType()); if (type.getKind() == 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; }
@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; } }
@SuppressWarnings("unchecked") private Object processAnnotationMemberValue(AnnotationValue value) { Object realValue = value.getValue(); if (realValue instanceof VariableElement) { realValue = ((VariableElement) realValue).getSimpleName().toString(); } else if (realValue instanceof AnnotationMirror) { realValue = processAnnotation((AnnotationMirror) realValue); } else if (realValue instanceof TypeMirror) { realValue = typeFactory.create((TypeMirror) realValue); } else if (realValue instanceof List) { realValue = ((List<AnnotationValue>) realValue).stream().map(AnnotationValue::getValue).collect(Collectors.toList()); if (((List) realValue).isEmpty()) { realValue = Collections.emptyList(); } else if (((List) realValue).get(0) instanceof AnnotationMirror) { realValue = ((List<AnnotationMirror>) realValue).stream().map(this::processAnnotation).collect(Collectors.toList()); } else if (((List) realValue).get(0) instanceof TypeMirror) { realValue = ((List<TypeMirror>) realValue).stream().map(typeFactory::create).collect(Collectors.toList()); } else if (((List) realValue).get(0) instanceof VariableElement) { realValue = ((List<VariableElement>) realValue).stream().map(v -> v.getSimpleName().toString()).collect(Collectors.toList()); } } return realValue; }
public TypeInfo create(TypeUse use, TypeMirror type) { switch (type.getKind()) { case VOID: return VoidTypeInfo.INSTANCE; case ERROR: case DECLARED: return create(use, (DeclaredType) type); case DOUBLE: case LONG: case FLOAT: case CHAR: case BYTE: case SHORT: case BOOLEAN: case INT: if (use != null && use.isNullable()) { throw new IllegalArgumentException("Primitive types cannot be annotated with @Nullable"); } return PrimitiveTypeInfo.PRIMITIVES.get(type.getKind().name().toLowerCase()); case TYPEVAR: return create(use, (TypeVariable) type); case ARRAY: return create(use, (ArrayType) type); default: throw new IllegalArgumentException("Illegal type " + type + " of kind " + type.getKind()); } }
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; } } } }
private ConstantInfo fieldMethod(VariableElement modelField, boolean allowAnyJavaType) { Set<Modifier> mods = modelField.getModifiers(); if (!mods.contains(Modifier.PUBLIC)) { return null; } TypeInfo type = typeFactory.create(modelField.asType()); checkConstantType(modelField, type, modelField.asType(),allowAnyJavaType); Doc doc = docFactory.createDoc(modelField); return new ConstantInfo(doc, modelField.getSimpleName().toString(), type); }
public ArrayTypeInfo create(TypeUse use, ArrayType type) { TypeMirror componentType = type.getComponentType(); return new ArrayTypeInfo(create(componentType), use != null && use.isNullable()); }
TypeUse typeUse = TypeUse.createParamTypeUse(env, modelMethods.toArray(new ExecutableElement[modelMethods.size()]), i); try { typeInfo = typeFactory.create(typeUse, type); } catch (Exception e) { GenException ex = new GenException(param, e.getMessage()); TypeInfo unresolvedTypeInfo; try { unresolvedTypeInfo = typeFactory.create(typeUse, methodType2.getParameterTypes().get(i)); } catch (Exception e) { throw new GenException(param, e.getMessage());
private void doTest(Class<?> container, Consumer<Map<String, TypeInfo>> assertion) throws Exception { Map<String, TypeInfo> reflectedMap = Stream.of(container.getDeclaredMethods()).filter(m -> Modifier.isPublic(m.getModifiers())). collect(Collectors.toMap(Method::getName, m -> TypeReflectionFactory.create(m.getGenericReturnType()))); assertion.accept(reflectedMap); Utils.assertProcess((proc, env) -> { TypeMirrorFactory factory = new TypeMirrorFactory(proc.getElementUtils(), proc.getTypeUtils()); TypeElement modelMap = proc.getElementUtils().getTypeElement(container.getName()); Map<String, TypeInfo> collect = modelMap.getEnclosedElements().stream(). flatMap(Helper.FILTER_METHOD). filter(elt -> elt.getModifiers().contains(javax.lang.model.element.Modifier.PUBLIC)). collect(Collectors.toMap(m -> m.getSimpleName().toString(), m -> factory.create(m.getReturnType()))); assertion.accept(collect); }); }
this.concrete = isClass && !modelElt.getModifiers().contains(Modifier.ABSTRACT); try { this.type = (ClassTypeInfo) typeFactory.create(modelElt.asType()); } catch (ClassCastException e) { throw new GenException(modelElt, "Data object must be a plain java class with no type parameters"); .map(e -> (ClassTypeInfo) typeFactory.create(e)).forEach(abstractSuperTypes::add); superType = (ClassTypeInfo) typeFactory.create(superClass); superTypes.add(superType); if (methodElt.getSimpleName().toString().equals("toJson") && methodElt.getParameters().isEmpty() && typeFactory.create(methodElt.getReturnType()).getKind() == ClassKind.JSON_OBJECT) { jsonifiable = true;
TypeInfo type; try { type = factory.create(elt.asType()); } catch (Exception e) { System.out.println("Could not resolve doc link for type " + elt.getQualifiedName());
@Override public String resolveTypeLink(TypeElement elt, Coordinate coordinate) { TypeInfo type = null; try { type = factory.create(elt.asType()); } catch (Exception e) { System.out.println("Could not resolve doc link for type " + elt.getQualifiedName()); return null; } if (type.getKind().equals(ClassKind.ENUM) && ((EnumTypeInfo)type).isGen()) { String baselink = null; if (coordinate == null) baselink = "../"; else baselink = "../../" + coordinate.getArtifactId() + "/"; return baselink + "enums.html#" + elt.getSimpleName().toString(); } if (type.getKind().equals(ClassKind.DATA_OBJECT)) { String baselink = null; if (coordinate == null) baselink = "../"; else baselink = "../../" + coordinate.getArtifactId() + "/"; return baselink + "dataobjects.html#" + elt.getSimpleName().toString(); } if (type.getKind().equals(ClassKind.API)) { ApiTypeInfo api = (ApiTypeInfo)type.getRaw(); return "../../scaladocs/" + api.translateName("scala").replace('.', '/') + ".html"; } return null; }
); type = (EnumTypeInfo) new TypeMirrorFactory(elementUtils, typeUtils).create(modelElt.asType()); Helper.checkUnderModule(this, "@VertxGen"); values = elementUtils.
VariableElement paramElt = setterElt.getParameters().get(0); propTypeMirror = paramElt.asType(); propType = typeFactory.create(propTypeMirror); propKind = PropertyKind.forType(propType.getKind()); propertyDeprecated |= setterElt.getAnnotation(Deprecated.class) != null; TypeInfo getterType = typeFactory.create(getterTypeMirror); PropertyKind getterKind = PropertyKind.forType(getterType.getKind()); propertyDeprecated |= getterElt.getAnnotation(Deprecated.class) != null; VariableElement paramElt = adderElt.getParameters().get(0); TypeMirror adderTypeMirror = paramElt.asType(); TypeInfo adderType = typeFactory.create(adderTypeMirror); if (propTypeMirror != null) { if (propKind != PropertyKind.LIST && propKind != PropertyKind.SET) { VariableElement paramElt = adderElt.getParameters().get(1); TypeMirror adderTypeMirror = paramElt.asType(); TypeInfo adderType = typeFactory.create(adderTypeMirror); if (propTypeMirror != null) { if (propKind != PropertyKind.MAP) {
tag.getValue(), resolvedElt, typeFactory.create(resolvedType), tag.getValue().substring(matcher.end())); token = new Token.InlineTag(token.getValue(), tagLink);
throw new GenException(elem, "Can only have one interface per file"); type = typeFactory.create(elem.asType()).getRaw(); Helper.checkUnderModule(this, "@VertxGen"); ifaceFQCN = elem.asType().toString(); TypeInfo superTypeInfo; try { superTypeInfo = typeFactory.create(tmSuper); } catch (IllegalArgumentException e) { throw new GenException(elem, e.getMessage()); case API: { try { ApiTypeInfo superType = (ApiTypeInfo) typeFactory.create(tmSuper).getRaw(); if (superType.isConcrete()) { if (concrete) { for (int i = 0; i< size;i++) { TypeMirror q = abc.getTypeArguments().get(i); TypeInfo ti = typeFactory.create(q); list.add(ti);
TypeInfo declaringType = typeFactory.create(declaringElt.asType()); ClassTypeInfo type = typeFactory.create(declaringElt.asType()).getRaw(); forEach(overridenMethodElt -> { modelMethods.add(overridenMethodElt); ownerTypes.add(typeFactory.create((DeclaredType) ancestorElt.asType()).getRaw()); }); TypeInfo returnType; try { returnType = typeFactory.create(returnTypeUse, methodType.getReturnType()); } catch (Exception e) { GenException genEx = new GenException(modelMethod, e.getMessage());