public AnnotationConfiguration() 
{
	  
		super();
}

 public AnnotationConfiguration(SettingsFactory sf) 
{
		super( sf );
}

 protected  void add(Document doc) throws MappingException 
{
		boolean ejb3Xml = "entity-mappings".equals( doc.getRootElement().getName() );
		if ( inSecondPass ) {
			//if in second pass bypass the queueing, getExtendedQueue reuse this method
			if ( !ejb3Xml ) super.add( doc );
		}
		else {
			if ( ! ejb3Xml ) {
				final Element hmNode = doc.getRootElement();
				Attribute packNode = hmNode.attribute( "package" );
				String defaultPackage = packNode != null
						? packNode.getValue()
						: "";
				Set< String > entityNames = new HashSet< String >();
				findClassNames( defaultPackage, hmNode, entityNames );
				for ( String entity : entityNames ) {
					hbmEntities.put( entity, doc );
				}
				hbmDocuments.add( doc );
			}
			else {
				List< String > classnames = ( (EJB3ReflectionManager) reflectionManager ).getXMLContext().addDocument( doc );
				for ( String classname : classnames ) {
					try {
						annotatedClasses.add( reflectionManager.classForName( classname, this.getClass() ) );
					}
					catch (ClassNotFoundException e) {
						throw new AnnotationException( "Unable to load class defined in XML: " + classname, e );
					}
				}
			}
		}
}

 public AnnotationConfiguration addAnnotatedClass(Class persistentClass) throws MappingException 
{
		XClass persistentXClass = reflectionManager.toXClass( persistentClass );
		try {
			annotatedClasses.add( persistentXClass );
			return this;
		}
		catch (MappingException me) {
			log.error( "Could not compile the mapping annotations", me );
			throw me;
		}
}

Read a mapping from the class annotation metadata (JSR 175).

 public Configuration addInputStream(InputStream xmlInputStream) throws MappingException 
{
		try {
			List errors = new ArrayList();
			SAXReader saxReader = xmlHelper.createSAXReader( "XML InputStream", errors, getEntityResolver() );
			try {
				saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
				//saxReader.setFeature( "http://apache.org/xml/features/validation/dynamic", true );
				//set the default schema locators
				saxReader.setProperty(
						"http://apache.org/xml/properties/schema/external-schemaLocation",
						"http://java.sun.com/xml/ns/persistence/orm orm_1_0.xsd"
				);
			}
			catch (SAXException e) {
				saxReader.setValidation( false );
			}
			org.dom4j.Document doc = saxReader
					.read( new InputSource( xmlInputStream ) );
			if ( errors.size() != 0 ) {
				throw new MappingException( "invalid mapping", (Throwable) errors.get( 0 ) );
			}
			add( doc );
			return this;
		}
		catch (DocumentException e) {
			throw new MappingException( "Could not parse mapping document in input stream", e );
		}
		finally {
			try {
				xmlInputStream.close();
			}
			catch (IOException ioe) {
				log.warn( "Could not close input stream", ioe );
			}
		}
}

 public AnnotationConfiguration addPackage(String packageName) throws MappingException 
{
		log.info( "Mapping package " + packageName );
		try {
			AnnotationBinder.bindPackage( packageName, createExtendedMappings() );
			return this;
		}
		catch (MappingException me) {
			log.error( "Could not compile the mapping annotations", me );
			throw me;
		}
}

Read package level metadata

 public SessionFactory buildSessionFactory() throws HibernateException 
{
		//add validator events if the jar is available
		boolean enableValidatorListeners = ! "false".equalsIgnoreCase( getProperty( "hibernate.validator.autoregister_listeners" ) );
		Class validateEventListenerClass = null;
		try {
			validateEventListenerClass = ReflectHelper.classForName(
					"org.hibernate.validator.event.ValidateEventListener",
					AnnotationConfiguration.class );
		}
		catch (ClassNotFoundException e) {
			//validator is not present
			log.debug( "Validator not present in classpath, ignoring event listener registration" );
		}
		if (enableValidatorListeners && validateEventListenerClass != null) {
			//TODO so much duplication
			Object validateEventListener;
			try {
				validateEventListener = validateEventListenerClass.newInstance();
			}
			catch (Exception e) {
				throw new AnnotationException("Unable to load Validator event listener", e );
			}
			{
				boolean present = false;
				PreInsertEventListener[] listeners = getEventListeners().getPreInsertEventListeners();
				if (listeners != null) {
					for ( Object eventListener : listeners ) {
						//not isAssignableFrom since the user could subclass
						present = present || validateEventListenerClass == eventListener.getClass();
					}
					if (!present) {
						int length = listeners.length + 1;
						PreInsertEventListener[] newListeners = new PreInsertEventListener[length];
						for ( int i = 0 ; i <  length - 1 ; i++ ) {
							newListeners[i] = listeners[i];
						}
						newListeners[length-1] = (PreInsertEventListener) validateEventListener;
						getEventListeners().setPreInsertEventListeners(newListeners);
					}
				}
				else {
					getEventListeners().setPreInsertEventListeners(
							new PreInsertEventListener[] { (PreInsertEventListener) validateEventListener }
					);
				}
			}
			//update event listener
			{
				boolean present = false;
				PreUpdateEventListener[] listeners = getEventListeners().getPreUpdateEventListeners();
				if (listeners != null) {
					for ( Object eventListener : listeners ) {
						//not isAssignableFrom since the user could subclass
						present = present || validateEventListenerClass == eventListener.getClass();
					}
					if (!present) {
						int length = listeners.length + 1;
						PreUpdateEventListener[] newListeners = new PreUpdateEventListener[length];
						for ( int i = 0 ; i <  length - 1 ; i++ ) {
							newListeners[i] = listeners[i];
						}
						newListeners[length-1] = (PreUpdateEventListener) validateEventListener;
						getEventListeners().setPreUpdateEventListeners(newListeners);
					}
				}
				else {
					getEventListeners().setPreUpdateEventListeners(
							new PreUpdateEventListener[] { (PreUpdateEventListener) validateEventListener }
					);
				}
			}
		}
		//add search events if the jar is available
		boolean enableSearchListeners = ! "false".equalsIgnoreCase( getProperty( "hibernate.search.autoregister_listeners" ) );
		Class searchEventListenerClass = null;
		try {
			searchEventListenerClass = ReflectHelper.classForName(
					"org.hibernate.search.event.FullTextIndexEventListener",
					AnnotationConfiguration.class );
		}
		catch (ClassNotFoundException e) {
			//search is not present
			log.debug( "Search not present in classpath, ignoring event listener registration" );
		}
		if (enableSearchListeners && searchEventListenerClass != null) {
			//TODO so much duplication
			Object searchEventListener;
			try {
				searchEventListener = searchEventListenerClass.newInstance();
			}
			catch (Exception e) {
				throw new AnnotationException("Unable to load Search event listener", e );
			}
			{
				boolean present = false;
				PostInsertEventListener[] listeners = getEventListeners().getPostInsertEventListeners();
				if (listeners != null) {
					for ( Object eventListener : listeners ) {
						//not isAssignableFrom since the user could subclass
						present = present || searchEventListenerClass == eventListener.getClass();
					}
					if (!present) {
						int length = listeners.length + 1;
						PostInsertEventListener[] newListeners = new PostInsertEventListener[length];
						for ( int i = 0 ; i <  length - 1 ; i++ ) {
							newListeners[i] = listeners[i];
						}
						newListeners[length-1] = (PostInsertEventListener) searchEventListener;
						getEventListeners().setPostInsertEventListeners(newListeners);
					}
				}
				else {
					getEventListeners().setPostInsertEventListeners(
							new PostInsertEventListener[] { (PostInsertEventListener) searchEventListener }
					);
				}
			}
			{
				boolean present = false;
				PostUpdateEventListener[] listeners = getEventListeners().getPostUpdateEventListeners();
				if (listeners != null) {
					for ( Object eventListener : listeners ) {
						//not isAssignableFrom since the user could subclass
						present = present || searchEventListenerClass == eventListener.getClass();
					}
					if (!present) {
						int length = listeners.length + 1;
						PostUpdateEventListener[] newListeners = new PostUpdateEventListener[length];
						for ( int i = 0 ; i <  length - 1 ; i++ ) {
							newListeners[i] = listeners[i];
						}
						newListeners[length-1] = (PostUpdateEventListener) searchEventListener;
						getEventListeners().setPostUpdateEventListeners(newListeners);
					}
				}
				else {
					getEventListeners().setPostUpdateEventListeners(
							new PostUpdateEventListener[] { (PostUpdateEventListener) searchEventListener }
					);
				}
			}
			{
				boolean present = false;
				PostDeleteEventListener[] listeners = getEventListeners().getPostDeleteEventListeners();
				if (listeners != null) {
					for ( Object eventListener : listeners ) {
						//not isAssignableFrom since the user could subclass
						present = present || searchEventListenerClass == eventListener.getClass();
					}
					if (!present) {
						int length = listeners.length + 1;
						PostDeleteEventListener[] newListeners = new PostDeleteEventListener[length];
						for ( int i = 0 ; i <  length - 1 ; i++ ) {
							newListeners[i] = listeners[i];
						}
						newListeners[length-1] = (PostDeleteEventListener) searchEventListener;
						getEventListeners().setPostDeleteEventListeners(newListeners);
					}
				}
				else {
					getEventListeners().setPostDeleteEventListeners(
							new PostDeleteEventListener[] { (PostDeleteEventListener) searchEventListener }
					);
				}
			}
		}
		return super.buildSessionFactory();
}

 public ExtendedMappings createExtendedMappings() 
{
		return new ExtendedMappings(
				classes,
				collections,
				tables,
				namedQueries,
				namedSqlQueries,
				sqlResultSetMappings,
				defaultNamedQueryNames,
				defaultNamedNativeQueryNames,
				defaultSqlResulSetMappingNames,
				defaultNamedGenerators,
				imports,
				secondPasses,
				propertyReferences,
				namingStrategy,
				typeDefs,
				filterDefinitions,
				namedGenerators,
				joins,
				classTypes,
				extendsQueue,
				tableNameBinding, columnNameBindingPerTable, auxiliaryDatabaseObjects,
				generatorTables,
				tableUniqueConstraints,
				mappedByResolver,
				propertyRefResolver,
				reflectionManager
		);
}

 public ReflectionManager getReflectionManager() 
{
		return reflectionManager;
}

 protected List orderAndFillHierarchy(List original) 
{
		//TODO remove embeddable
		List< XClass > copy = new ArrayList< XClass >( original );
		//for each class, copy all the relevent hierarchy
		for ( XClass clazz : original ) {
			XClass superClass = clazz.getSuperclass();
			while ( superClass != null && ! reflectionManager.equals( superClass, Object.class ) && ! copy.contains( superClass ) ) {
				if ( superClass.isAnnotationPresent( Entity.class )
						|| superClass.isAnnotationPresent( MappedSuperclass.class ) ) {
					copy.add( superClass );
				}
				superClass = superClass.getSuperclass();
			}
		}
		List< XClass > workingCopy = new ArrayList< XClass >( copy );
		List< XClass > newList = new ArrayList< XClass >( copy.size() );
		while ( workingCopy.size()  > 0 ) {
			XClass clazz = workingCopy.get( 0 );
			orderHierarchy( workingCopy, newList, copy, clazz );
		}
		return newList;
}

 protected  void parseMappingElement(Element subelement,
    String name) 
{
		Attribute rsrc = subelement.attribute( "resource" );
		Attribute file = subelement.attribute( "file" );
		Attribute jar = subelement.attribute( "jar" );
		Attribute pckg = subelement.attribute( "package" );
		Attribute clazz = subelement.attribute( "class" );
		if ( rsrc != null ) {
			log.debug( name + "< -" + rsrc );
			addResource( rsrc.getValue() );
		}
		else if ( jar != null ) {
			log.debug( name + "< -" + jar );
			addJar( new File( jar.getValue() ) );
		}
		else if ( file != null ) {
			log.debug( name + "< -" + file );
			addFile( file.getValue() );
		}
		else if ( pckg != null ) {
			log.debug( name + "< -" + pckg );
			addPackage( pckg.getValue() );
		}
		else if ( clazz != null ) {
			log.debug( name + "< -" + clazz );
			Class loadedClass = null;
			try {
				loadedClass = ReflectHelper.classForName( clazz.getValue() );
			}
			catch (ClassNotFoundException cnf) {
				throw new MappingException(
						"Unable to load class declared as < mapping class=\"" + clazz.getValue() + "\"/ > in the configuration:",
						cnf
				);
			}
			catch (NoClassDefFoundError ncdf) {
				throw new MappingException(
						"Unable to load class declared as < mapping class=\"" + clazz.getValue() + "\"/ > in the configuration:",
						ncdf
				);
			}
			addAnnotatedClass( loadedClass );
		}
		else {
			throw new MappingException( "< mapping > element in configuration specifies no attributes" );
		}
}

 protected  void reset() 
{
		super.reset();
		namedGenerators = new HashMap();
		joins = new HashMap< String, Map< String, Join > >();
		classTypes = new HashMap< String, AnnotatedClassType >();
		generatorTables = new HashMap< String, Properties >();
		defaultNamedQueryNames = new HashSet< String >();
		defaultNamedNativeQueryNames = new HashSet< String >();
		defaultSqlResulSetMappingNames = new HashSet< String >();
		defaultNamedGenerators = new HashSet< String >();
		tableUniqueConstraints = new HashMap< Table, List< String[] > >();
		mappedByResolver = new HashMap< String, String >();
		propertyRefResolver = new HashMap< String, String >();
		annotatedClasses = new ArrayList< XClass >();
		caches = new ArrayList< CacheHolder >();
		hbmEntities = new HashMap< String, Document >();
		annotatedClassEntities = new HashMap< String, XClass >();
		hbmDocuments = new ArrayList< Document >();
		namingStrategy = EJB3NamingStrategy.INSTANCE;
		setEntityResolver( new EJB3DTDEntityResolver() );
		reflectionManager = new EJB3ReflectionManager();
}

 protected  void secondPassCompile() throws MappingException 
{
		log.debug( "Execute first pass mapping processing" );
		//build annotatedClassEntities
		{
			List< XClass > tempAnnotatedClasses = new ArrayList< XClass >( annotatedClasses.size() );
			for ( XClass clazz : annotatedClasses ) {
				if ( clazz.isAnnotationPresent( Entity.class ) ) {
					annotatedClassEntities.put( clazz.getName(), clazz );
					tempAnnotatedClasses.add( clazz );
				}
				else if ( clazz.isAnnotationPresent( MappedSuperclass.class ) ) {
					tempAnnotatedClasses.add( clazz );
				}
				//only keep MappedSuperclasses and Entity in this list
			}
			annotatedClasses = tempAnnotatedClasses;
		}
		//process default values first
		if ( ! isDefaultProcessed ) {
			AnnotationBinder.bindDefaults( createExtendedMappings() );
			isDefaultProcessed = true;
		}
		//process entities
		if ( precedence == null ) precedence = getProperties().getProperty( ARTEFACT );
		if ( precedence == null ) precedence = DEFAULT_PRECEDENCE;
		StringTokenizer precedences = new StringTokenizer( precedence, ",; ", false );
		if ( ! precedences.hasMoreElements() ) {
			throw new MappingException( ARTEFACT + " cannot be empty: " + precedence );
		}
		while ( precedences.hasMoreElements() ) {
			String artifact = (String) precedences.nextElement();
			removeConflictedArtifact( artifact );
			processArtifactsOfType( artifact );
		}
		int cacheNbr = caches.size();
		for ( int index = 0; index <  cacheNbr ; index++ ) {
			CacheHolder cacheHolder = caches.get( index );
			if ( cacheHolder.isClass ) {
				super.setCacheConcurrencyStrategy(
						cacheHolder.role, cacheHolder.usage, cacheHolder.region, cacheHolder.cacheLazy
				);
			}
			else {
				super.setCollectionCacheConcurrencyStrategy( cacheHolder.role, cacheHolder.usage, cacheHolder.region );
			}
		}
		caches.clear();
		inSecondPass = true;
		processFkSecondPassInOrder();
		Iterator iter = secondPasses.iterator();
		while ( iter.hasNext() ) {
			SecondPass sp = (SecondPass) iter.next();
			//do the second pass of fk before the others and remove them
			if ( sp instanceof CreateKeySecondPass ) {
				sp.doSecondPass( classes );
				iter.remove();
			}
		}
		//process OneToManySecondPass in order: first
		iter = secondPasses.iterator();
		while ( iter.hasNext() ) {
			SecondPass sp = (SecondPass) iter.next();
			if ( sp instanceof CreateKeySecondPass ) {
				sp.doSecondPass( classes );
				iter.remove();
			}
		}
		super.secondPassCompile();
		inSecondPass = false;
		Iterator tables = (Iterator< Map.Entry< Table, List< String[] > > >) tableUniqueConstraints.entrySet().iterator();
		Table table;
		Map.Entry entry;
		String keyName;
		int uniqueIndexPerTable;
		while ( tables.hasNext() ) {
			entry = (Map.Entry) tables.next();
			table = (Table) entry.getKey();
			List< String[] > uniqueConstraints = (List< String[] >) entry.getValue();
			uniqueIndexPerTable = 0;
			for ( String[] columnNames : uniqueConstraints ) {
				keyName = "key" + uniqueIndexPerTable++;
				buildUniqueKeyFromColumnNames( columnNames, table, keyName );
			}
		}
		boolean applyOnDdl = getProperties().getProperty(
				"hibernate.validator.apply_to_ddl", //org.hibernate.validator.Environment.APPLY_TO_DDL
				"true" )
				.equalsIgnoreCase( "true" );
		Constructor validatorCtr = null;
		Method applyMethod = null;
		try {
			Class classValidator = ReflectHelper.classForName("org.hibernate.validator.ClassValidator", this.getClass() );
			Class messageInterpolator = ReflectHelper.classForName("org.hibernate.validator.MessageInterpolator", this.getClass() );
			validatorCtr = classValidator.getDeclaredConstructor( new Class[] {
					Class.class, ResourceBundle.class, messageInterpolator, Map.class, ReflectionManager.class
					}
			);
			applyMethod = classValidator.getMethod( "apply", PersistentClass.class );
		}
		catch (ClassNotFoundException e) {
			log.info( "Hibernate Validator not found: ignoring");
		}
		catch (NoSuchMethodException e) {
			throw new AnnotationException(e);
		}
		if ( applyMethod != null && applyOnDdl) {
			for ( PersistentClass persistentClazz : (Collection< PersistentClass >) classes.values() ) {
				//integrate the validate framework
				String className = persistentClazz.getClassName();
				if ( StringHelper.isNotEmpty( className ) ) {
					try {
						Object validator = validatorCtr.newInstance(
								ReflectHelper.classForName( className ), null, null, null, reflectionManager
						);
						applyMethod.invoke( validator, persistentClazz );
					}
					catch (Exception e) {
						log.warn("Unable to apply constraints on DDL for " + className, e);
					}
				}
			}
		}
}

 public  void setCacheConcurrencyStrategy(String clazz,
    String concurrencyStrategy,
    String region,
    boolean cacheLazyProperty) throws MappingException 
{
		caches.add( new CacheHolder( clazz, concurrencyStrategy, region, true, cacheLazyProperty ) );
}

 public  void setCollectionCacheConcurrencyStrategy(String collectionRole,
    String concurrencyStrategy,
    String region) throws MappingException 
{
		caches.add( new CacheHolder( collectionRole, concurrencyStrategy, region, false, false ) );
}

 public  void setPrecedence(String precedence) 
{
		this.precedence = precedence;
}