コード例 #1
0
  private void serialize(Serializer serializer, Collection<EntityType> models) {
    for (EntityType model : models) {
      try {
        Type type = conf.getTypeMappings().getPathType(model, model, true);
        String packageName = type.getPackageName();
        String className =
            !packageName.isEmpty()
                ? (packageName + "." + type.getSimpleName())
                : type.getSimpleName();

        // skip if type is excluded class or in excluded package
        if (conf.isExcludedPackage(model.getPackageName())
            || conf.isExcludedClass(model.getFullName())) {
          continue;
        }

        Set<TypeElement> elements = context.typeElements.get(model.getFullName());

        if (elements == null) {
          elements = new HashSet<TypeElement>();
        }
        for (Property property : model.getProperties()) {
          if (property.getType().getCategory() == TypeCategory.CUSTOM) {
            Set<TypeElement> customElements =
                context.typeElements.get(property.getType().getFullName());
            if (customElements != null) {
              elements.addAll(customElements);
            }
          }
        }

        processingEnv
            .getMessager()
            .printMessage(Kind.NOTE, "Generating " + className + " for " + elements);
        JavaFileObject fileObject =
            processingEnv
                .getFiler()
                .createSourceFile(className, elements.toArray(new Element[elements.size()]));
        Writer writer = fileObject.openWriter();
        try {
          SerializerConfig serializerConfig = conf.getSerializerConfig(model);
          serializer.serialize(model, serializerConfig, new JavaWriter(writer));
        } finally {
          if (writer != null) {
            writer.close();
          }
        }

      } catch (IOException e) {
        System.err.println(e.getMessage());
        processingEnv.getMessager().printMessage(Kind.ERROR, e.getMessage());
      }
    }
  }
コード例 #2
0
 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);
     }
   }
 }
コード例 #3
0
 private void addSupertypeFields(EntityType model, Set<EntityType> handled) {
   if (handled.add(model)) {
     for (Supertype supertype : model.getSuperTypes()) {
       EntityType entityType = context.allTypes.get(supertype.getType().getFullName());
       if (entityType != null) {
         addSupertypeFields(entityType, handled);
         supertype.setEntityType(entityType);
         model.include(supertype);
       }
     }
   }
 }
コード例 #4
0
 private EntityType createEntityType(Class<?> cl, Map<String, EntityType> types) {
   if (types.containsKey(cl.getName())) {
     return types.get(cl.getName());
   } else {
     EntityType type = new EntityType(new ClassType(TypeCategory.ENTITY, cl));
     typeMappings.register(type, queryTypeFactory.create(type));
     if (!cl.getSuperclass().equals(Object.class)) {
       type.addSupertype(new Supertype(new ClassType(cl.getSuperclass())));
     }
     types.put(cl.getName(), type);
     allTypes.put(cl.getName(), type);
     return type;
   }
 }
コード例 #5
0
 private void validateMetaTypes() {
   for (Collection<EntityType> entityTypes :
       Arrays.asList(
           context.supertypes.values(),
           context.entityTypes.values(),
           context.extensionTypes.values(),
           context.embeddableTypes.values(),
           context.projectionTypes.values())) {
     for (EntityType entityType : entityTypes) {
       for (Property property : entityType.getProperties()) {
         if (property.getInits() != null && property.getInits().size() > 0) {
           validateInits(entityType, property);
         }
       }
     }
   }
 }
コード例 #6
0
 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 (entityType.getSuperType() != null) {
         superTypes.push(entityType.getSuperType().getType());
       }
       context.allTypes.put(superType.getFullName(), superEntityType);
     }
   }
 }
コード例 #7
0
  private void collectTypes()
      throws IOException, XMLStreamException, ClassNotFoundException, SecurityException,
          NoSuchMethodException {
    // super classes
    Iterator<?> superClassMappings = configuration.getMappedSuperclassMappings();
    while (superClassMappings.hasNext()) {
      MappedSuperclass msc = (MappedSuperclass) superClassMappings.next();
      EntityType entityType = createSuperType(msc.getMappedClass());
      if (msc.getDeclaredIdentifierProperty() != null) {
        handleProperty(entityType, msc.getMappedClass(), msc.getDeclaredIdentifierProperty());
      }
      Iterator<?> properties = msc.getDeclaredPropertyIterator();
      while (properties.hasNext()) {
        handleProperty(
            entityType, msc.getMappedClass(), (org.hibernate.mapping.Property) properties.next());
      }
    }

    // entity classes
    Iterator<?> classMappings = configuration.getClassMappings();
    while (classMappings.hasNext()) {
      PersistentClass pc = (PersistentClass) classMappings.next();
      EntityType entityType = createEntityType(pc.getMappedClass());
      if (pc.getDeclaredIdentifierProperty() != null) {
        handleProperty(entityType, pc.getMappedClass(), pc.getDeclaredIdentifierProperty());
      } else if (!pc.isInherited() && pc.hasIdentifierProperty()) {
        logger.info(entityType.toString() + pc.getIdentifierProperty());
        handleProperty(entityType, pc.getMappedClass(), pc.getIdentifierProperty());
      }
      Iterator<?> properties = pc.getDeclaredPropertyIterator();
      while (properties.hasNext()) {
        handleProperty(
            entityType, pc.getMappedClass(), (org.hibernate.mapping.Property) properties.next());
      }
    }
  }
コード例 #8
0
  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;
  }
コード例 #9
0
 private void handleProperty(EntityType entityType, Class<?> cl, org.hibernate.mapping.Property p)
     throws NoSuchMethodException, ClassNotFoundException {
   Type propertyType = getType(cl, p.getName());
   if (p.isComposite()) {
     Class<?> embeddedClass = Class.forName(propertyType.getFullName());
     EntityType embeddedType = createEmbeddableType(embeddedClass);
     Iterator<?> properties = ((Component) p.getValue()).getPropertyIterator();
     while (properties.hasNext()) {
       handleProperty(
           embeddedType, embeddedClass, (org.hibernate.mapping.Property) properties.next());
     }
     propertyType = embeddedType;
   } else if (propertyType.getCategory() == TypeCategory.ENTITY) {
     propertyType = createEntityType(Class.forName(propertyType.getFullName()));
   }
   AnnotatedElement annotated = getAnnotatedElement(cl, p.getName());
   Property property = createProperty(entityType, p.getName(), propertyType, annotated);
   entityType.addProperty(property);
 }
コード例 #10
0
 protected void validateInits(EntityType entityType, Property property) {
   for (String init : property.getInits()) {
     if (!init.startsWith("*") && property.getType() instanceof EntityType) {
       String initProperty = init.contains(".") ? init.substring(0, init.indexOf('.')) : init;
       if (!((EntityType) property.getType()).getPropertyNames().contains(initProperty)) {
         processingEnv
             .getMessager()
             .printMessage(
                 Kind.ERROR,
                 "Illegal inits of "
                     + entityType.getFullName()
                     + "."
                     + property.getName()
                     + ": "
                     + initProperty
                     + " not found");
       }
     }
   }
 }
コード例 #11
0
  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();
  }