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 bindIdentifierGenerators() {
   if (hibernateMapping.getIdentifierGenerator() == null) {
     return;
   }
   for (XMLHibernateMapping.XMLIdentifierGenerator identifierGeneratorElement :
       hibernateMapping.getIdentifierGenerator()) {
     metadata.registerIdentifierGenerator(
         identifierGeneratorElement.getName(), identifierGeneratorElement.getClazz());
   }
 }
 private void bindImports() {
   if (hibernateMapping.getImport() == null) {
     return;
   }
   for (XMLHibernateMapping.XMLImport importValue : hibernateMapping.getImport()) {
     String className = getClassName(importValue.getClazz());
     String rename = importValue.getRename();
     rename = (rename == null) ? StringHelper.unqualify(className) : rename;
     metadata.addImport(className, rename);
   }
 }
 private void bindTypeDefinitions() {
   if (hibernateMapping.getTypedef() == null) {
     return;
   }
   for (XMLHibernateMapping.XMLTypedef typedef : hibernateMapping.getTypedef()) {
     final Map<String, String> parameters = new HashMap<String, String>();
     for (XMLParamElement paramElement : typedef.getParam()) {
       parameters.put(paramElement.getName(), paramElement.getValue());
     }
     metadata.addTypeDefinition(new TypeDef(typedef.getName(), typedef.getClazz(), parameters));
   }
 }
 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 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();
  }
 private void bindResultSetMappings() {
   if (hibernateMapping.getResultset() == null) {
     return;
   }
   //			bindResultSetMappingDefinitions( element, null, mappings );
 }
 private void bindFetchProfiles() {
   if (hibernateMapping.getFetchProfile() == null) {
     return;
   }
   bindFetchProfiles(hibernateMapping.getFetchProfile(), null);
 }
 private MetaAttributeContext extractMetaAttributes() {
   return hibernateMapping.getMeta() == null
       ? new MetaAttributeContext(metadata.getMetaAttributeContext())
       : HbmHelper.extractMetaAttributeContext(
           hibernateMapping.getMeta(), true, metadata.getMetaAttributeContext());
 }