private void processProjectionTypes(Set<TypeElement> elements) { Set<Element> visited = new HashSet<Element>(); for (Element element : getElements(QueryProjection.class)) { Element parent = element.getEnclosingElement(); if (!elements.contains(parent) && !visited.contains(parent)) { EntityType model = elementHandler.handleProjectionType((TypeElement) parent); registerTypeElement(model.getFullName(), (TypeElement) parent); context.projectionTypes.put(model.getFullName(), model); visited.add(parent); } } }
private Set<TypeElement> processDelegateMethods() { Set<Element> delegateMethods = (Set) getElements(QueryDelegate.class); Set<TypeElement> typeElements = new HashSet<TypeElement>(); for (Element delegateMethod : delegateMethods) { ExecutableElement method = (ExecutableElement) delegateMethod; Element element = delegateMethod.getEnclosingElement(); String name = method.getSimpleName().toString(); Type delegateType = typeFactory.getType(element.asType(), true); Type returnType = typeFactory.getType(method.getReturnType(), true); List<Parameter> parameters = elementHandler.transformParams(method.getParameters()); // remove first element parameters = parameters.subList(1, parameters.size()); EntityType entityType = null; for (AnnotationMirror annotation : delegateMethod.getAnnotationMirrors()) { if (TypeUtils.isAnnotationMirrorOfType(annotation, QueryDelegate.class)) { TypeMirror type = TypeUtils.getAnnotationValueAsTypeMirror(annotation, "value"); if (type != null) { entityType = typeFactory.getEntityType(type, true); } } } if (entityType != null) { registerTypeElement(entityType.getFullName(), (TypeElement) element); entityType.addDelegate( new Delegate(entityType, delegateType, name, parameters, returnType)); TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(entityType.getFullName()); boolean isAnnotated = false; for (Class<? extends Annotation> ann : conf.getEntityAnnotations()) { if (typeElement.getAnnotation(ann) != null) { isAnnotated = true; } } if (isAnnotated) { // handle also properties of entity type typeElements.add( processingEnv.getElementUtils().getTypeElement(entityType.getFullName())); } else { // skip handling properties context.extensionTypes.put(entityType.getFullName(), entityType); context.allTypes.put(entityType.getFullName(), entityType); } } } return typeElements; }
private void addExternalParents(EntityType entityType) { Deque<Type> superTypes = new ArrayDeque<Type>(); if (entityType.getSuperType() != null) { superTypes.push(entityType.getSuperType().getType()); } while (!superTypes.isEmpty()) { Type superType = superTypes.pop(); if (!context.allTypes.containsKey(superType.getFullName())) { TypeElement typeElement = processingEnv.getElementUtils().getTypeElement(superType.getFullName()); if (typeElement == null) { throw new IllegalStateException("Found no type for " + superType.getFullName()); } EntityType superEntityType = elementHandler.handleEntityType(typeElement); if (superEntityType.getSuperType() != null) { superTypes.push(superEntityType.getSuperType().getType()); } context.allTypes.put(superType.getFullName(), superEntityType); } } }
protected Set<TypeElement> collectElements() { Set<TypeElement> elements = new HashSet<TypeElement>(); // from delegate methods elements.addAll(processDelegateMethods()); // from class annotations for (Class<? extends Annotation> annotation : conf.getEntityAnnotations()) { for (Element element : getElements(annotation)) { if (element instanceof TypeElement) { elements.add((TypeElement) element); } } } // from package annotations if (conf.getEntitiesAnnotation() != null) { for (Element element : getElements(conf.getEntitiesAnnotation())) { AnnotationMirror mirror = TypeUtils.getAnnotationMirrorOfType(element, conf.getEntitiesAnnotation()); elements.addAll(TypeUtils.getAnnotationValuesAsElements(mirror, "value")); } } // from embedded annotations if (conf.getEmbeddedAnnotation() != null) { elements.addAll(getEmbeddedTypes()); } // from embedded if (conf.isUnknownAsEmbedded()) { elements.addAll(getTypeFromProperties(elements)); } // from annotation less supertypes elements.addAll(getAnnotationlessSupertypes(elements)); // register possible embedded types of non-tracked supertypes if (conf.getEmbeddedAnnotation() != null) { Class<? extends Annotation> embedded = conf.getEmbeddedAnnotation(); Set<TypeElement> embeddedElements = new HashSet<TypeElement>(); for (TypeElement element : elements) { TypeMirror superTypeMirror = element.getSuperclass(); while (superTypeMirror != null) { TypeElement superTypeElement = (TypeElement) processingEnv.getTypeUtils().asElement(superTypeMirror); if (superTypeElement != null) { List<? extends Element> enclosed = superTypeElement.getEnclosedElements(); for (Element child : enclosed) { if (child.getAnnotation(embedded) != null) { handleEmbeddedType(child, embeddedElements); } } superTypeMirror = superTypeElement.getSuperclass(); if (superTypeMirror instanceof NoType) { superTypeMirror = null; } } else { superTypeMirror = null; } } } // register found elements for (TypeElement element : embeddedElements) { if (!elements.contains(element)) { elementHandler.handleEntityType(element); } } } return elements; }
private void processAnnotations() { processExclusions(); Set<TypeElement> elements = collectElements(); // create meta models for (Element element : elements) { typeFactory.getEntityType(element.asType(), false); } for (Element element : elements) { typeFactory.getEntityType(element.asType(), true); } // add properties boolean embeddableAnn = conf.getEmbeddableAnnotation() != null; boolean altEntityAnn = conf.getAlternativeEntityAnnotation() != null; boolean superAnn = conf.getSuperTypeAnnotation() != null; for (TypeElement element : elements) { EntityType entityType = elementHandler.handleEntityType(element); registerTypeElement(entityType.getFullName(), element); if (element.getAnnotation(conf.getEntityAnnotation()) != null) { context.entityTypes.put(entityType.getFullName(), entityType); } else if (altEntityAnn && element.getAnnotation(conf.getAlternativeEntityAnnotation()) != null) { context.entityTypes.put(entityType.getFullName(), entityType); } else if (embeddableAnn && element.getAnnotation(conf.getEmbeddableAnnotation()) != null) { context.embeddableTypes.put(entityType.getFullName(), entityType); } else if (superAnn && element.getAnnotation(conf.getSuperTypeAnnotation()) != null) { context.supertypes.put(entityType.getFullName(), entityType); } else if (!entityType.getDelegates().isEmpty()) { context.extensionTypes.put(entityType.getFullName(), entityType); } else { context.embeddableTypes.put(entityType.getFullName(), entityType); } context.allTypes.put(entityType.getFullName(), entityType); } // track also methods from external entity types for (EntityType entityType : new ArrayList<EntityType>(typeFactory.getEntityTypes())) { String fullName = entityType.getFullName(); if (!context.allTypes.keySet().contains(fullName)) { // System.err.println(fullName); TypeElement element = processingEnv.getElementUtils().getTypeElement(fullName); if (element != null) { elementHandler.handleEntityType(element); } } } // add external parents for (Element element : elements) { EntityType entityType = typeFactory.getEntityType(element.asType(), false); addExternalParents(entityType); } // add properties from parents Set<EntityType> handled = new HashSet<EntityType>(); for (EntityType entityType : context.allTypes.values()) { addSupertypeFields(entityType, handled); } processProjectionTypes(elements); // extend entity types typeFactory.extendTypes(); context.clean(); }