@Override
  @SuppressWarnings({"unchecked"})
  public void prepare(MetadataSources sources) {
    // create a jandex index from the annotated classes
    Indexer indexer = new Indexer();
    for (Class<?> clazz : sources.getAnnotatedClasses()) {
      indexClass(indexer, clazz.getName().replace('.', '/') + ".class");
    }

    // add package-info from the configured packages
    for (String packageName : sources.getAnnotatedPackages()) {
      indexClass(indexer, packageName.replace('.', '/') + "/package-info.class");
    }

    index = indexer.complete();

    List<JaxbRoot<XMLEntityMappings>> mappings = new ArrayList<JaxbRoot<XMLEntityMappings>>();
    for (JaxbRoot<?> root : sources.getJaxbRootList()) {
      if (root.getRoot() instanceof XMLEntityMappings) {
        mappings.add((JaxbRoot<XMLEntityMappings>) root);
      }
    }
    if (!mappings.isEmpty()) {
      // process the xml configuration
      final OrmXmlParser ormParser = new OrmXmlParser(metadata);
      index = ormParser.parseAndUpdateIndex(mappings, index);
    }

    if (index.getAnnotations(PseudoJpaDotNames.DEFAULT_DELIMITED_IDENTIFIERS) != null) {
      metadata.setGloballyQuotedIdentifiers(true);
    }
  }
Exemplo n.º 2
0
 @Override
 @SuppressWarnings({"unchecked"})
 public void prepare(MetadataSources sources) {
   this.processors = new ArrayList<HibernateMappingProcessor>();
   for (JaxbRoot jaxbRoot : sources.getJaxbRootList()) {
     if (jaxbRoot.getRoot() instanceof XMLHibernateMapping) {
       processors.add(
           new HibernateMappingProcessor(metadata, (JaxbRoot<XMLHibernateMapping>) jaxbRoot));
     }
   }
 }
 public void bindMappingMetadata(List<String> processedEntityNames) {
   if (hibernateMapping.getClazzOrSubclassOrJoinedSubclass() == null) {
     return;
   }
   for (Object clazzOrSubclass : hibernateMapping.getClazzOrSubclassOrJoinedSubclass()) {
     if (XMLHibernateMapping.XMLClass.class.isInstance(clazzOrSubclass)) {
       XMLHibernateMapping.XMLClass clazz =
           XMLHibernateMapping.XMLClass.class.cast(clazzOrSubclass);
       new RootEntityBinder(this, clazz).process(clazz);
     } else if (XMLSubclassElement.class.isInstance(clazzOrSubclass)) {
       //					PersistentClass superModel = getSuperclass( mappings, element );
       //					handleSubclass( superModel, mappings, element, inheritedMetas );
     } else if (XMLJoinedSubclassElement.class.isInstance(clazzOrSubclass)) {
       //					PersistentClass superModel = getSuperclass( mappings, element );
       //					handleJoinedSubclass( superModel, mappings, element, inheritedMetas );
     } else if (XMLUnionSubclassElement.class.isInstance(clazzOrSubclass)) {
       //					PersistentClass superModel = getSuperclass( mappings, element );
       //					handleUnionSubclass( superModel, mappings, element, inheritedMetas );
     } else {
       throw new org.hibernate.metamodel.source.MappingException(
           "unknown type of class or subclass: " + clazzOrSubclass.getClass().getName(),
           jaxbRoot.getOrigin());
     }
   }
 }
 private void bindFilterDefinitions() {
   if (hibernateMapping.getFilterDef() == null) {
     return;
   }
   for (XMLHibernateMapping.XMLFilterDef filterDefinition : hibernateMapping.getFilterDef()) {
     final String name = filterDefinition.getName();
     final Map<String, Type> parameters = new HashMap<String, Type>();
     String condition = null;
     for (Object o : filterDefinition.getContent()) {
       if (o instanceof String) {
         // represents the condition
         if (condition != null) {
           // log?
         }
         condition = (String) o;
       } else if (o instanceof XMLHibernateMapping.XMLFilterDef.XMLFilterParam) {
         final XMLHibernateMapping.XMLFilterDef.XMLFilterParam paramElement =
             (XMLHibernateMapping.XMLFilterDef.XMLFilterParam) o;
         // todo : should really delay this resolution until later to allow typedef names
         parameters.put(
             paramElement.getName(),
             metadata.getTypeResolver().heuristicType(paramElement.getType()));
       } else {
         throw new MappingException("Unrecognized nested filter content", jaxbRoot.getOrigin());
       }
     }
     if (condition == null) {
       condition = filterDefinition.getCondition();
     }
     metadata.addFilterDefinition(new FilterDefinition(name, condition, parameters));
   }
 }
 private void bindDatabaseObjectDefinitions() {
   if (hibernateMapping.getDatabaseObject() == null) {
     return;
   }
   for (XMLHibernateMapping.XMLDatabaseObject databaseObjectElement :
       hibernateMapping.getDatabaseObject()) {
     final AuxiliaryDatabaseObject auxiliaryDatabaseObject;
     if (databaseObjectElement.getDefinition() != null) {
       final String className = databaseObjectElement.getDefinition().getClazz();
       try {
         auxiliaryDatabaseObject =
             (AuxiliaryDatabaseObject) classLoaderService().classForName(className).newInstance();
       } catch (ClassLoadingException e) {
         throw e;
       } catch (Exception e) {
         throw new MappingException(
             "could not instantiate custom database object class [" + className + "]",
             jaxbRoot.getOrigin());
       }
     } else {
       Set<String> dialectScopes = new HashSet<String>();
       if (databaseObjectElement.getDialectScope() != null) {
         for (XMLHibernateMapping.XMLDatabaseObject.XMLDialectScope dialectScope :
             databaseObjectElement.getDialectScope()) {
           dialectScopes.add(dialectScope.getName());
         }
       }
       auxiliaryDatabaseObject =
           new BasicAuxiliaryDatabaseObjectImpl(
               databaseObjectElement.getCreate(), databaseObjectElement.getDrop(), dialectScopes);
     }
     metadata.addAuxiliaryDatabaseObject(auxiliaryDatabaseObject);
   }
 }
 private void bindNamedQueries() {
   if (hibernateMapping.getQueryOrSqlQuery() == null) {
     return;
   }
   for (Object queryOrSqlQuery : hibernateMapping.getQueryOrSqlQuery()) {
     if (XMLQueryElement.class.isInstance(queryOrSqlQuery)) {
       //					bindNamedQuery( element, null, mappings );
     } else if (XMLSqlQueryElement.class.isInstance(queryOrSqlQuery)) {
       //				bindNamedSQLQuery( element, null, mappings );
     } else {
       throw new MappingException(
           "unknown type of query: " + queryOrSqlQuery.getClass().getName(), jaxbRoot.getOrigin());
     }
   }
 }
 public void bindFetchProfiles(
     List<XMLFetchProfileElement> fetchProfiles, String containingEntityName) {
   for (XMLFetchProfileElement fetchProfile : fetchProfiles) {
     String profileName = fetchProfile.getName();
     Set<FetchProfile.Fetch> fetches = new HashSet<FetchProfile.Fetch>();
     for (XMLFetchProfileElement.XMLFetch fetch : fetchProfile.getFetch()) {
       String entityName = fetch.getEntity() == null ? containingEntityName : fetch.getEntity();
       if (entityName == null) {
         throw new MappingException(
             "could not determine entity for fetch-profile fetch ["
                 + profileName
                 + "]:["
                 + fetch.getAssociation()
                 + "]",
             jaxbRoot.getOrigin());
       }
       fetches.add(new FetchProfile.Fetch(entityName, fetch.getAssociation(), fetch.getStyle()));
     }
     metadata.addFetchProfile(new FetchProfile(profileName, fetches));
   }
 }
  public HibernateMappingProcessor(
      MetadataImplementor metadata, JaxbRoot<XMLHibernateMapping> jaxbRoot) {
    this.metadata = metadata;
    this.jaxbRoot = jaxbRoot;

    this.hibernateMapping = jaxbRoot.getRoot();
    this.mappingDefaults =
        new OverriddenMappingDefaults(
            metadata.getMappingDefaults(),
            hibernateMapping.getPackage(),
            hibernateMapping.getSchema(),
            hibernateMapping.getCatalog(),
            null,
            null,
            hibernateMapping.getDefaultCascade(),
            hibernateMapping.getDefaultAccess(),
            hibernateMapping.isDefaultLazy());

    autoImport = hibernateMapping.isAutoImport();

    metaAttributeContext = extractMetaAttributes();
  }
 @Override
 public Origin getOrigin() {
   return jaxbRoot.getOrigin();
 }