[hibernate-commits] Hibernate SVN: r10743 - in branches/Lucene_Integration/HibernateExt/metadata/src: java/org/hibernate/search java/org/hibernate/search/engine java/org/hibernate/search/event java/org/hibernate/search/query java/org/hibernate/search/util test/org/hibernate/search/test test/org/hibernate/search/test/bridge test/org/hibernate/search/test/fieldAccess test/org/hibernate/search/test/inheritance test/org/hibernate/search/test/query test/org/hibernate/search/test/session

[hibernate-commits at lists.jboss.org]

Author: epbernard
Date: 2006-11-06 20:16:53 -0500 (Mon, 06 Nov 2006)
New Revision: 10743

Added:
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/FullTextSession.java
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextEventListener.java
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/FullTextQueryImpl.java
Removed:
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/LuceneSession.java
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/LuceneEventListener.java
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/LuceneQueryImpl.java
Modified:
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/engine/DocumentBuilder.java
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/ScrollableResultsImpl.java
   branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/util/ContextHelper.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/FSDirectoryTest.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TestCase.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/bridge/BridgeTest.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/fieldAccess/FieldAccessTest.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/inheritance/InheritanceTest.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/query/LuceneQueryTest.java
   branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/session/MassIndexTest.java
Log:
ANN-488 renaming

Copied: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/FullTextSession.java (from rev 10742, branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/LuceneSession.java)
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/LuceneSession.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/FullTextSession.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -0,0 +1,465 @@
+//$Id: $
+package org.hibernate.search;
+
+import java.io.Serializable;
+import java.sql.Connection;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.locks.ReentrantLock;
+
+import javax.transaction.Status;
+
+import org.hibernate.CacheMode;
+import org.hibernate.Criteria;
+import org.hibernate.EntityMode;
+import org.hibernate.Filter;
+import org.hibernate.FlushMode;
+import org.hibernate.HibernateException;
+import org.hibernate.LockMode;
+import org.hibernate.Query;
+import org.hibernate.ReplicationMode;
+import org.hibernate.SQLQuery;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+import org.hibernate.engine.query.ParameterMetadata;
+import org.hibernate.impl.SessionImpl;
+import org.hibernate.search.query.FullTextQueryImpl;
+import org.hibernate.search.event.FullTextEventListener;
+import org.hibernate.search.util.ContextHelper;
+import org.hibernate.search.engine.DocumentBuilder;
+import org.hibernate.search.backend.UpdateWork;
+import org.hibernate.search.backend.Work;
+import org.hibernate.search.backend.WorkQueue;
+import org.hibernate.search.backend.impl.BatchLuceneWorkQueue;
+import org.hibernate.search.backend.impl.PostTransactionWorkQueueSynchronization;
+import org.hibernate.search.store.DirectoryProvider;
+import org.hibernate.stat.SessionStatistics;
+import org.hibernate.type.Type;
+import org.apache.lucene.document.Document;
+
+/**
+ * Lucene aware session that allows lucene query creations
+ *
+ * @author Emmanuel Bernard
+ */
+public class FullTextSession implements Session {
+	private final SessionImpl session;
+	private PostTransactionWorkQueueSynchronization postTransactionWorkQueueSynch;
+
+	public FullTextSession(Session session) {
+		this.session = (SessionImpl) session;
+	}
+
+	/**
+	 * Execute a Lucene query and retrieve managed objects of type entities (or their indexed subclasses)
+     * If entities is empty, include all indexed entities
+     * 
+	 * @param entities must be immutable for the lifetime of the query object
+	 */
+	public Query createLuceneQuery(org.apache.lucene.search.Query luceneQuery, Class... entities) {
+		return new FullTextQueryImpl( luceneQuery, entities, session, new ParameterMetadata(null, null) );
+	}
+
+	/**
+	 * (re)index an entity.
+	 * Non indexable entities are ignored
+	 * The entity must be associated with the session
+	 *
+	 * @param entity must not be null
+	 */
+	public void index(Object entity) {
+		if (entity == null) return;
+		Class clazz = entity.getClass();
+		FullTextEventListener listener = ContextHelper.getLuceneEventListener( session );
+		DocumentBuilder<Object> builder = listener.getDocumentBuilders().get( clazz );
+		if ( builder != null ) {
+			Serializable id = session.getIdentifier( entity );
+			Document doc = builder.getDocument( entity, id );
+			UpdateWork work = new UpdateWork( id, entity.getClass(), doc );
+			processWork( work, listener.getDocumentBuilders(), listener.getLockableDirectoryProviders() );
+		}
+		//TODO
+		//need to add elements in a queue kept at the Session level
+		//the queue will be processed by a Lucene(Auto)FlushEventListener
+		//note that we could keep this queue somewhere in the event listener in the mean time but that requires
+		// a synchronized hashmap holding this queue on a per session basis plus some session house keeping (yuk)
+		//an other solution would be to subclass SessionImpl instead of having this LuceneSession delecation model
+		// this is an open discussion
+	}
+
+	private void processWork(Work work, Map<Class, DocumentBuilder<Object>> documentBuilders,
+							 Map<DirectoryProvider, ReentrantLock> lockableDirectoryProviders) {
+		if ( session.isTransactionInProgress() ) {
+			if ( postTransactionWorkQueueSynch == null || postTransactionWorkQueueSynch.isConsumed() ) {
+				postTransactionWorkQueueSynch = createWorkQueueSync( documentBuilders, lockableDirectoryProviders);
+				session.getTransaction().registerSynchronization( postTransactionWorkQueueSynch );
+			}
+			postTransactionWorkQueueSynch.add( work );
+		}
+		else {
+			//no transaction work right away
+			PostTransactionWorkQueueSynchronization sync =
+					createWorkQueueSync( documentBuilders, lockableDirectoryProviders );
+			sync.add( work );
+			sync.afterCompletion( Status.STATUS_COMMITTED );
+		}
+	}
+
+	private PostTransactionWorkQueueSynchronization createWorkQueueSync(
+			Map<Class, DocumentBuilder<Object>> documentBuilders,
+			Map<DirectoryProvider, ReentrantLock> lockableDirectoryProviders) {
+		WorkQueue workQueue = new BatchLuceneWorkQueue( documentBuilders, lockableDirectoryProviders );
+		return new PostTransactionWorkQueueSynchronization( workQueue );
+	}
+
+	public Query createSQLQuery(String sql, String returnAlias, Class returnClass) {
+		return session.createSQLQuery( sql, returnAlias, returnClass );
+	}
+
+	public Query createSQLQuery(String sql, String[] returnAliases, Class[] returnClasses) {
+		return session.createSQLQuery( sql, returnAliases, returnClasses );
+	}
+
+	public int delete(String query) throws HibernateException {
+		return session.delete( query );
+	}
+
+	public int delete(String query, Object value, Type type) throws HibernateException {
+		return session.delete( query, value, type );
+	}
+
+	public int delete(String query, Object[] values, Type[] types) throws HibernateException {
+		return session.delete( query, values, types );
+	}
+
+	public Collection filter(Object collection, String filter) throws HibernateException {
+		return session.filter( collection, filter );
+	}
+
+	public Collection filter(Object collection, String filter, Object value, Type type) throws HibernateException {
+		return session.filter( collection, filter, value, type );
+	}
+
+	public Collection filter(Object collection, String filter, Object[] values, Type[] types) throws HibernateException {
+		return session.filter( collection, filter, values, types );
+	}
+
+	public List find(String query) throws HibernateException {
+		return session.find( query );
+	}
+
+	public List find(String query, Object value, Type type) throws HibernateException {
+		return session.find( query, value, type );
+	}
+
+	public List find(String query, Object[] values, Type[] types) throws HibernateException {
+		return session.find( query, values, types );
+	}
+
+	public Iterator iterate(String query) throws HibernateException {
+		return session.iterate( query );
+	}
+
+	public Iterator iterate(String query, Object value, Type type) throws HibernateException {
+		return session.iterate( query, value, type );
+	}
+
+	public Iterator iterate(String query, Object[] values, Type[] types) throws HibernateException {
+		return session.iterate( query, values, types );
+	}
+
+	public void save(String entityName, Object object, Serializable id) throws HibernateException {
+		session.save( entityName, object, id );
+	}
+
+	public void save(Object object, Serializable id) throws HibernateException {
+		session.save( object, id );
+	}
+
+	public Object saveOrUpdateCopy(String entityName, Object object) throws HibernateException {
+		return session.saveOrUpdateCopy( entityName, object );
+	}
+
+	public Object saveOrUpdateCopy(String entityName, Object object, Serializable id) throws HibernateException {
+		return session.saveOrUpdateCopy( entityName, object, id );
+	}
+
+	public Object saveOrUpdateCopy(Object object) throws HibernateException {
+		return session.saveOrUpdateCopy( object );
+	}
+
+	public Object saveOrUpdateCopy(Object object, Serializable id) throws HibernateException {
+		return session.saveOrUpdateCopy( object, id );
+	}
+
+	public void update(String entityName, Object object, Serializable id) throws HibernateException {
+		session.update( entityName, object, id );
+	}
+
+	public void update(Object object, Serializable id) throws HibernateException {
+		session.update( object, id );
+	}
+
+	public Transaction beginTransaction() throws HibernateException {
+		return session.beginTransaction();
+	}
+
+	public void cancelQuery() throws HibernateException {
+		session.cancelQuery();
+	}
+
+	public void clear() {
+		session.clear();
+	}
+
+	public Connection close() throws HibernateException {
+		return session.close();
+	}
+
+	public Connection connection() throws HibernateException {
+		return session.connection();
+	}
+
+	public boolean contains(Object object) {
+		return session.contains( object );
+	}
+
+	public Criteria createCriteria(String entityName) {
+		return session.createCriteria( entityName );
+	}
+
+	public Criteria createCriteria(String entityName, String alias) {
+		return session.createCriteria( entityName, alias );
+	}
+
+	public Criteria createCriteria(Class persistentClass) {
+		return session.createCriteria( persistentClass );
+	}
+
+	public Criteria createCriteria(Class persistentClass, String alias) {
+		return session.createCriteria( persistentClass, alias );
+	}
+
+	public Query createFilter(Object collection, String queryString) throws HibernateException {
+		return session.createFilter( collection, queryString );
+	}
+
+	public Query createQuery(String queryString) throws HibernateException {
+		return session.createQuery( queryString );
+	}
+
+	public SQLQuery createSQLQuery(String queryString) throws HibernateException {
+		return session.createSQLQuery( queryString );
+	}
+
+	public void delete(String entityName, Object object) throws HibernateException {
+		session.delete( entityName, object );
+	}
+
+	public void delete(Object object) throws HibernateException {
+		session.delete( object );
+	}
+
+	public void disableFilter(String filterName) {
+		session.disableFilter( filterName );
+	}
+
+	public Connection disconnect() throws HibernateException {
+		return session.disconnect();
+	}
+
+	public Filter enableFilter(String filterName) {
+		return session.enableFilter( filterName );
+	}
+
+	public void evict(Object object) throws HibernateException {
+		session.evict( object );
+	}
+
+	public void flush() throws HibernateException {
+		session.flush();
+	}
+
+	public Object get(Class clazz, Serializable id) throws HibernateException {
+		return session.get( clazz, id );
+	}
+
+	public Object get(Class clazz, Serializable id, LockMode lockMode) throws HibernateException {
+		return session.get( clazz, id, lockMode );
+	}
+
+	public Object get(String entityName, Serializable id) throws HibernateException {
+		return session.get( entityName, id );
+	}
+
+	public Object get(String entityName, Serializable id, LockMode lockMode) throws HibernateException {
+		return session.get( entityName, id, lockMode );
+	}
+
+	public CacheMode getCacheMode() {
+		return session.getCacheMode();
+	}
+
+	public LockMode getCurrentLockMode(Object object) throws HibernateException {
+		return session.getCurrentLockMode( object );
+	}
+
+	public Filter getEnabledFilter(String filterName) {
+		return session.getEnabledFilter( filterName );
+	}
+
+	public EntityMode getEntityMode() {
+		return session.getEntityMode();
+	}
+
+	public String getEntityName(Object object) throws HibernateException {
+		return session.getEntityName( object );
+	}
+
+	public FlushMode getFlushMode() {
+		return session.getFlushMode();
+	}
+
+	public Serializable getIdentifier(Object object) throws HibernateException {
+		return session.getIdentifier( object );
+	}
+
+	public Query getNamedQuery(String queryName) throws HibernateException {
+		return session.getNamedQuery( queryName );
+	}
+
+	public org.hibernate.Session getSession(EntityMode entityMode) {
+		return session.getSession( entityMode );
+	}
+
+	public SessionFactory getSessionFactory() {
+		return session.getSessionFactory();
+	}
+
+	public SessionStatistics getStatistics() {
+		return session.getStatistics();
+	}
+
+	public Transaction getTransaction() {
+		return session.getTransaction();
+	}
+
+	public boolean isConnected() {
+		return session.isConnected();
+	}
+
+	public boolean isDirty() throws HibernateException {
+		return session.isDirty();
+	}
+
+	public boolean isOpen() {
+		return session.isOpen();
+	}
+
+	public Object load(String entityName, Serializable id) throws HibernateException {
+		return session.load( entityName, id );
+	}
+
+	public Object load(String entityName, Serializable id, LockMode lockMode) throws HibernateException {
+		return session.load( entityName, id, lockMode );
+	}
+
+	public void load(Object object, Serializable id) throws HibernateException {
+		session.load( object, id );
+	}
+
+	public Object load(Class theClass, Serializable id) throws HibernateException {
+		return session.load( theClass, id );
+	}
+
+	public Object load(Class theClass, Serializable id, LockMode lockMode) throws HibernateException {
+		return session.load( theClass, id, lockMode );
+	}
+
+	public void lock(String entityName, Object object, LockMode lockMode) throws HibernateException {
+		session.lock( entityName, object, lockMode );
+	}
+
+	public void lock(Object object, LockMode lockMode) throws HibernateException {
+		session.lock( object, lockMode );
+	}
+
+	public Object merge(String entityName, Object object) throws HibernateException {
+		return session.merge( entityName, object );
+	}
+
+	public Object merge(Object object) throws HibernateException {
+		return session.merge( object );
+	}
+
+	public void persist(String entityName, Object object) throws HibernateException {
+		session.persist( entityName, object );
+	}
+
+	public void persist(Object object) throws HibernateException {
+		session.persist( object );
+	}
+
+	public void reconnect() throws HibernateException {
+		session.reconnect();
+	}
+
+	public void reconnect(Connection connection) throws HibernateException {
+		session.reconnect( connection );
+	}
+
+	public void refresh(Object object) throws HibernateException {
+		session.refresh( object );
+	}
+
+	public void refresh(Object object, LockMode lockMode) throws HibernateException {
+		session.refresh( object, lockMode );
+	}
+
+	public void replicate(String entityName, Object object, ReplicationMode replicationMode) throws HibernateException {
+		session.replicate( entityName, object, replicationMode );
+	}
+
+	public void replicate(Object object, ReplicationMode replicationMode) throws HibernateException {
+		session.replicate( object, replicationMode );
+	}
+
+	public Serializable save(String entityName, Object object) throws HibernateException {
+		return session.save( entityName, object );
+	}
+
+	public Serializable save(Object object) throws HibernateException {
+		return session.save( object );
+	}
+
+	public void saveOrUpdate(String entityName, Object object) throws HibernateException {
+		session.saveOrUpdate( entityName, object );
+	}
+
+	public void saveOrUpdate(Object object) throws HibernateException {
+		session.saveOrUpdate( object );
+	}
+
+	public void setCacheMode(CacheMode cacheMode) {
+		session.setCacheMode( cacheMode );
+	}
+
+	public void setFlushMode(FlushMode flushMode) {
+		session.setFlushMode( flushMode );
+	}
+
+	public void setReadOnly(Object entity, boolean readOnly) {
+		session.setReadOnly( entity, readOnly );
+	}
+
+	public void update(String entityName, Object object) throws HibernateException {
+		session.update( entityName, object );
+	}
+
+	public void update(Object object) throws HibernateException {
+		session.update( object );
+	}
+}

Deleted: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/LuceneSession.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/LuceneSession.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/LuceneSession.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -1,466 +0,0 @@
-//$Id: $
-package org.hibernate.search;
-
-import java.io.Serializable;
-import java.sql.Connection;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.locks.ReentrantLock;
-
-import javax.transaction.Status;
-
-import org.hibernate.CacheMode;
-import org.hibernate.Criteria;
-import org.hibernate.EntityMode;
-import org.hibernate.Filter;
-import org.hibernate.FlushMode;
-import org.hibernate.HibernateException;
-import org.hibernate.LockMode;
-import org.hibernate.Query;
-import org.hibernate.ReplicationMode;
-import org.hibernate.SQLQuery;
-import org.hibernate.Session;
-import org.hibernate.SessionFactory;
-import org.hibernate.Transaction;
-import org.hibernate.event.PostInsertEventListener;
-import org.hibernate.engine.query.ParameterMetadata;
-import org.hibernate.impl.SessionImpl;
-import org.hibernate.search.query.LuceneQueryImpl;
-import org.hibernate.search.event.LuceneEventListener;
-import org.hibernate.search.util.ContextHelper;
-import org.hibernate.search.engine.DocumentBuilder;
-import org.hibernate.search.backend.UpdateWork;
-import org.hibernate.search.backend.Work;
-import org.hibernate.search.backend.WorkQueue;
-import org.hibernate.search.backend.impl.BatchLuceneWorkQueue;
-import org.hibernate.search.backend.impl.PostTransactionWorkQueueSynchronization;
-import org.hibernate.search.store.DirectoryProvider;
-import org.hibernate.stat.SessionStatistics;
-import org.hibernate.type.Type;
-import org.apache.lucene.document.Document;
-
-/**
- * Lucene aware session that allows lucene query creations
- *
- * @author Emmanuel Bernard
- */
-public class LuceneSession implements Session {
-	private final SessionImpl session;
-	private PostTransactionWorkQueueSynchronization postTransactionWorkQueueSynch;
-
-	public LuceneSession(Session session) {
-		this.session = (SessionImpl) session;
-	}
-
-	/**
-	 * Execute a Lucene query and retrieve managed objects of type entities (or their indexed subclasses)
-     * If entities is empty, include all indexed entities
-     * 
-	 * @param entities must be immutable for the lifetime of the query object
-	 */
-	public Query createLuceneQuery(org.apache.lucene.search.Query luceneQuery, Class... entities) {
-		return new LuceneQueryImpl( luceneQuery, entities, session, new ParameterMetadata(null, null) );
-	}
-
-	/**
-	 * (re)index an entity.
-	 * Non indexable entities are ignored
-	 * The entity must be associated with the session
-	 *
-	 * @param entity must not be null
-	 */
-	public void index(Object entity) {
-		if (entity == null) return;
-		Class clazz = entity.getClass();
-		LuceneEventListener listener = ContextHelper.getLuceneEventListener( session );
-		DocumentBuilder<Object> builder = listener.getDocumentBuilders().get( clazz );
-		if ( builder != null ) {
-			Serializable id = session.getIdentifier( entity );
-			Document doc = builder.getDocument( entity, id );
-			UpdateWork work = new UpdateWork( id, entity.getClass(), doc );
-			processWork( work, listener.getDocumentBuilders(), listener.getLockableDirectoryProviders() );
-		}
-		//TODO
-		//need to add elements in a queue kept at the Session level
-		//the queue will be processed by a Lucene(Auto)FlushEventListener
-		//note that we could keep this queue somewhere in the event listener in the mean time but that requires
-		// a synchronized hashmap holding this queue on a per session basis plus some session house keeping (yuk)
-		//an other solution would be to subclass SessionImpl instead of having this LuceneSession delecation model
-		// this is an open discussion
-	}
-
-	private void processWork(Work work, Map<Class, DocumentBuilder<Object>> documentBuilders,
-							 Map<DirectoryProvider, ReentrantLock> lockableDirectoryProviders) {
-		if ( session.isTransactionInProgress() ) {
-			if ( postTransactionWorkQueueSynch == null || postTransactionWorkQueueSynch.isConsumed() ) {
-				postTransactionWorkQueueSynch = createWorkQueueSync( documentBuilders, lockableDirectoryProviders);
-				session.getTransaction().registerSynchronization( postTransactionWorkQueueSynch );
-			}
-			postTransactionWorkQueueSynch.add( work );
-		}
-		else {
-			//no transaction work right away
-			PostTransactionWorkQueueSynchronization sync =
-					createWorkQueueSync( documentBuilders, lockableDirectoryProviders );
-			sync.add( work );
-			sync.afterCompletion( Status.STATUS_COMMITTED );
-		}
-	}
-
-	private PostTransactionWorkQueueSynchronization createWorkQueueSync(
-			Map<Class, DocumentBuilder<Object>> documentBuilders,
-			Map<DirectoryProvider, ReentrantLock> lockableDirectoryProviders) {
-		WorkQueue workQueue = new BatchLuceneWorkQueue( documentBuilders, lockableDirectoryProviders );
-		return new PostTransactionWorkQueueSynchronization( workQueue );
-	}
-
-	public Query createSQLQuery(String sql, String returnAlias, Class returnClass) {
-		return session.createSQLQuery( sql, returnAlias, returnClass );
-	}
-
-	public Query createSQLQuery(String sql, String[] returnAliases, Class[] returnClasses) {
-		return session.createSQLQuery( sql, returnAliases, returnClasses );
-	}
-
-	public int delete(String query) throws HibernateException {
-		return session.delete( query );
-	}
-
-	public int delete(String query, Object value, Type type) throws HibernateException {
-		return session.delete( query, value, type );
-	}
-
-	public int delete(String query, Object[] values, Type[] types) throws HibernateException {
-		return session.delete( query, values, types );
-	}
-
-	public Collection filter(Object collection, String filter) throws HibernateException {
-		return session.filter( collection, filter );
-	}
-
-	public Collection filter(Object collection, String filter, Object value, Type type) throws HibernateException {
-		return session.filter( collection, filter, value, type );
-	}
-
-	public Collection filter(Object collection, String filter, Object[] values, Type[] types) throws HibernateException {
-		return session.filter( collection, filter, values, types );
-	}
-
-	public List find(String query) throws HibernateException {
-		return session.find( query );
-	}
-
-	public List find(String query, Object value, Type type) throws HibernateException {
-		return session.find( query, value, type );
-	}
-
-	public List find(String query, Object[] values, Type[] types) throws HibernateException {
-		return session.find( query, values, types );
-	}
-
-	public Iterator iterate(String query) throws HibernateException {
-		return session.iterate( query );
-	}
-
-	public Iterator iterate(String query, Object value, Type type) throws HibernateException {
-		return session.iterate( query, value, type );
-	}
-
-	public Iterator iterate(String query, Object[] values, Type[] types) throws HibernateException {
-		return session.iterate( query, values, types );
-	}
-
-	public void save(String entityName, Object object, Serializable id) throws HibernateException {
-		session.save( entityName, object, id );
-	}
-
-	public void save(Object object, Serializable id) throws HibernateException {
-		session.save( object, id );
-	}
-
-	public Object saveOrUpdateCopy(String entityName, Object object) throws HibernateException {
-		return session.saveOrUpdateCopy( entityName, object );
-	}
-
-	public Object saveOrUpdateCopy(String entityName, Object object, Serializable id) throws HibernateException {
-		return session.saveOrUpdateCopy( entityName, object, id );
-	}
-
-	public Object saveOrUpdateCopy(Object object) throws HibernateException {
-		return session.saveOrUpdateCopy( object );
-	}
-
-	public Object saveOrUpdateCopy(Object object, Serializable id) throws HibernateException {
-		return session.saveOrUpdateCopy( object, id );
-	}
-
-	public void update(String entityName, Object object, Serializable id) throws HibernateException {
-		session.update( entityName, object, id );
-	}
-
-	public void update(Object object, Serializable id) throws HibernateException {
-		session.update( object, id );
-	}
-
-	public Transaction beginTransaction() throws HibernateException {
-		return session.beginTransaction();
-	}
-
-	public void cancelQuery() throws HibernateException {
-		session.cancelQuery();
-	}
-
-	public void clear() {
-		session.clear();
-	}
-
-	public Connection close() throws HibernateException {
-		return session.close();
-	}
-
-	public Connection connection() throws HibernateException {
-		return session.connection();
-	}
-
-	public boolean contains(Object object) {
-		return session.contains( object );
-	}
-
-	public Criteria createCriteria(String entityName) {
-		return session.createCriteria( entityName );
-	}
-
-	public Criteria createCriteria(String entityName, String alias) {
-		return session.createCriteria( entityName, alias );
-	}
-
-	public Criteria createCriteria(Class persistentClass) {
-		return session.createCriteria( persistentClass );
-	}
-
-	public Criteria createCriteria(Class persistentClass, String alias) {
-		return session.createCriteria( persistentClass, alias );
-	}
-
-	public Query createFilter(Object collection, String queryString) throws HibernateException {
-		return session.createFilter( collection, queryString );
-	}
-
-	public Query createQuery(String queryString) throws HibernateException {
-		return session.createQuery( queryString );
-	}
-
-	public SQLQuery createSQLQuery(String queryString) throws HibernateException {
-		return session.createSQLQuery( queryString );
-	}
-
-	public void delete(String entityName, Object object) throws HibernateException {
-		session.delete( entityName, object );
-	}
-
-	public void delete(Object object) throws HibernateException {
-		session.delete( object );
-	}
-
-	public void disableFilter(String filterName) {
-		session.disableFilter( filterName );
-	}
-
-	public Connection disconnect() throws HibernateException {
-		return session.disconnect();
-	}
-
-	public Filter enableFilter(String filterName) {
-		return session.enableFilter( filterName );
-	}
-
-	public void evict(Object object) throws HibernateException {
-		session.evict( object );
-	}
-
-	public void flush() throws HibernateException {
-		session.flush();
-	}
-
-	public Object get(Class clazz, Serializable id) throws HibernateException {
-		return session.get( clazz, id );
-	}
-
-	public Object get(Class clazz, Serializable id, LockMode lockMode) throws HibernateException {
-		return session.get( clazz, id, lockMode );
-	}
-
-	public Object get(String entityName, Serializable id) throws HibernateException {
-		return session.get( entityName, id );
-	}
-
-	public Object get(String entityName, Serializable id, LockMode lockMode) throws HibernateException {
-		return session.get( entityName, id, lockMode );
-	}
-
-	public CacheMode getCacheMode() {
-		return session.getCacheMode();
-	}
-
-	public LockMode getCurrentLockMode(Object object) throws HibernateException {
-		return session.getCurrentLockMode( object );
-	}
-
-	public Filter getEnabledFilter(String filterName) {
-		return session.getEnabledFilter( filterName );
-	}
-
-	public EntityMode getEntityMode() {
-		return session.getEntityMode();
-	}
-
-	public String getEntityName(Object object) throws HibernateException {
-		return session.getEntityName( object );
-	}
-
-	public FlushMode getFlushMode() {
-		return session.getFlushMode();
-	}
-
-	public Serializable getIdentifier(Object object) throws HibernateException {
-		return session.getIdentifier( object );
-	}
-
-	public Query getNamedQuery(String queryName) throws HibernateException {
-		return session.getNamedQuery( queryName );
-	}
-
-	public org.hibernate.Session getSession(EntityMode entityMode) {
-		return session.getSession( entityMode );
-	}
-
-	public SessionFactory getSessionFactory() {
-		return session.getSessionFactory();
-	}
-
-	public SessionStatistics getStatistics() {
-		return session.getStatistics();
-	}
-
-	public Transaction getTransaction() {
-		return session.getTransaction();
-	}
-
-	public boolean isConnected() {
-		return session.isConnected();
-	}
-
-	public boolean isDirty() throws HibernateException {
-		return session.isDirty();
-	}
-
-	public boolean isOpen() {
-		return session.isOpen();
-	}
-
-	public Object load(String entityName, Serializable id) throws HibernateException {
-		return session.load( entityName, id );
-	}
-
-	public Object load(String entityName, Serializable id, LockMode lockMode) throws HibernateException {
-		return session.load( entityName, id, lockMode );
-	}
-
-	public void load(Object object, Serializable id) throws HibernateException {
-		session.load( object, id );
-	}
-
-	public Object load(Class theClass, Serializable id) throws HibernateException {
-		return session.load( theClass, id );
-	}
-
-	public Object load(Class theClass, Serializable id, LockMode lockMode) throws HibernateException {
-		return session.load( theClass, id, lockMode );
-	}
-
-	public void lock(String entityName, Object object, LockMode lockMode) throws HibernateException {
-		session.lock( entityName, object, lockMode );
-	}
-
-	public void lock(Object object, LockMode lockMode) throws HibernateException {
-		session.lock( object, lockMode );
-	}
-
-	public Object merge(String entityName, Object object) throws HibernateException {
-		return session.merge( entityName, object );
-	}
-
-	public Object merge(Object object) throws HibernateException {
-		return session.merge( object );
-	}
-
-	public void persist(String entityName, Object object) throws HibernateException {
-		session.persist( entityName, object );
-	}
-
-	public void persist(Object object) throws HibernateException {
-		session.persist( object );
-	}
-
-	public void reconnect() throws HibernateException {
-		session.reconnect();
-	}
-
-	public void reconnect(Connection connection) throws HibernateException {
-		session.reconnect( connection );
-	}
-
-	public void refresh(Object object) throws HibernateException {
-		session.refresh( object );
-	}
-
-	public void refresh(Object object, LockMode lockMode) throws HibernateException {
-		session.refresh( object, lockMode );
-	}
-
-	public void replicate(String entityName, Object object, ReplicationMode replicationMode) throws HibernateException {
-		session.replicate( entityName, object, replicationMode );
-	}
-
-	public void replicate(Object object, ReplicationMode replicationMode) throws HibernateException {
-		session.replicate( object, replicationMode );
-	}
-
-	public Serializable save(String entityName, Object object) throws HibernateException {
-		return session.save( entityName, object );
-	}
-
-	public Serializable save(Object object) throws HibernateException {
-		return session.save( object );
-	}
-
-	public void saveOrUpdate(String entityName, Object object) throws HibernateException {
-		session.saveOrUpdate( entityName, object );
-	}
-
-	public void saveOrUpdate(Object object) throws HibernateException {
-		session.saveOrUpdate( object );
-	}
-
-	public void setCacheMode(CacheMode cacheMode) {
-		session.setCacheMode( cacheMode );
-	}
-
-	public void setFlushMode(FlushMode flushMode) {
-		session.setFlushMode( flushMode );
-	}
-
-	public void setReadOnly(Object entity, boolean readOnly) {
-		session.setReadOnly( entity, readOnly );
-	}
-
-	public void update(String entityName, Object object) throws HibernateException {
-		session.update( entityName, object );
-	}
-
-	public void update(Object object) throws HibernateException {
-		session.update( object );
-	}
-}

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/engine/DocumentBuilder.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/engine/DocumentBuilder.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/engine/DocumentBuilder.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -26,7 +26,7 @@
 import org.hibernate.search.bridge.BridgeFactory;
 import org.hibernate.search.bridge.FieldBridge;
 import org.hibernate.search.bridge.IdFieldBridge;
-import org.hibernate.search.event.LuceneEventListener;
+import org.hibernate.search.event.FullTextEventListener;
 import org.hibernate.search.store.DirectoryProvider;
 import org.hibernate.search.util.BinderHelper;
 import org.hibernate.reflection.ReflectionManager;
@@ -305,7 +305,7 @@
 		}
 	}
 
-	public static Serializable getDocumentId(LuceneEventListener listener, Class clazz, Document document) {
+	public static Serializable getDocumentId(FullTextEventListener listener, Class clazz, Document document) {
 		DocumentBuilder builder = listener.getDocumentBuilders().get( clazz );
 		if ( builder == null ) throw new HibernateException( "No Lucene configuration set up for: " + clazz.getName() );
 		return (Serializable) builder.getIdBridge().get( builder.getIdKeywordName(), document );

Copied: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextEventListener.java (from rev 10742, branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/LuceneEventListener.java)
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/LuceneEventListener.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextEventListener.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -0,0 +1,180 @@
+//$Id$
+package org.hibernate.search.event;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantLock;
+import javax.transaction.Status;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.document.Document;
+import org.hibernate.HibernateException;
+import org.hibernate.cfg.AnnotationConfiguration;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.event.AbstractEvent;
+import org.hibernate.event.Initializable;
+import org.hibernate.event.PostDeleteEvent;
+import org.hibernate.event.PostDeleteEventListener;
+import org.hibernate.event.PostInsertEvent;
+import org.hibernate.event.PostInsertEventListener;
+import org.hibernate.event.PostUpdateEvent;
+import org.hibernate.event.PostUpdateEventListener;
+import org.hibernate.search.Environment;
+import org.hibernate.search.annotations.Indexed;
+import org.hibernate.search.backend.AddWork;
+import org.hibernate.search.backend.DeleteWork;
+import org.hibernate.search.backend.UpdateWork;
+import org.hibernate.search.backend.Work;
+import org.hibernate.search.backend.WorkQueue;
+import org.hibernate.search.backend.impl.BatchLuceneWorkQueue;
+import org.hibernate.search.backend.impl.PostTransactionWorkQueueSynchronization;
+import org.hibernate.search.engine.DocumentBuilder;
+import org.hibernate.search.store.DirectoryProvider;
+import org.hibernate.search.store.DirectoryProviderFactory;
+import org.hibernate.mapping.PersistentClass;
+import org.hibernate.reflection.ReflectionManager;
+import org.hibernate.reflection.XClass;
+import org.hibernate.util.ReflectHelper;
+
+/**
+ * This listener supports setting a parent directory for all generated index files.
+ * It also supports setting the analyzer class to be used.
+ *
+ * @author Gavin King
+ * @author Emmanuel Bernard
+ * @author Mattias Arbin
+ */
+//TODO work on sharing the same indexWriters and readers across a single post operation...
+//TODO implement and use a LockableDirectoryProvider that wraps a DP to handle the lock inside the LDP
+public class FullTextEventListener implements PostDeleteEventListener, PostInsertEventListener,
+		PostUpdateEventListener, Initializable {
+	ReflectionManager reflectionManager;
+
+	//FIXME keeping this here is a bad decision since you might want to search indexes wo maintain it
+	@Deprecated
+	public Map<Class, DocumentBuilder<Object>> getDocumentBuilders() {
+		return documentBuilders;
+	}
+
+
+	private Map<Class, DocumentBuilder<Object>> documentBuilders = new HashMap<Class, DocumentBuilder<Object>>();
+	//keep track of the index modifiers per DirectoryProvider since multiple entity can use the same directory provider
+	private Map<DirectoryProvider, ReentrantLock> lockableDirectoryProviders =
+			new HashMap<DirectoryProvider, ReentrantLock>();
+	private boolean initialized;
+
+	private static final Log log = LogFactory.getLog( FullTextEventListener.class );
+
+	public void initialize(Configuration cfg) {
+		if ( initialized ) return;
+		//yuk
+		reflectionManager = ( (AnnotationConfiguration) cfg ).createExtendedMappings().getReflectionManager();
+
+		Class analyzerClass;
+		String analyzerClassName = cfg.getProperty( Environment.ANALYZER_CLASS );
+		if ( analyzerClassName != null ) {
+			try {
+				analyzerClass = ReflectHelper.classForName( analyzerClassName );
+			}
+			catch (Exception e) {
+				throw new HibernateException(
+						"Lucene analyzer class '" + analyzerClassName + "' defined in property '" + Environment.ANALYZER_CLASS + "' could not be found.",
+						e
+				);
+			}
+		}
+		else {
+			analyzerClass = StandardAnalyzer.class;
+		}
+		// Initialize analyzer
+		Analyzer analyzer;
+		try {
+			analyzer = (Analyzer) analyzerClass.newInstance();
+		}
+		catch (ClassCastException e) {
+			throw new HibernateException(
+					"Lucene analyzer does not implement " + Analyzer.class.getName() + ": " + analyzerClassName
+			);
+		}
+		catch (Exception e) {
+			throw new HibernateException( "Failed to instantiate lucene analyzer with type " + analyzerClassName );
+		}
+
+		Iterator iter = cfg.getClassMappings();
+		DirectoryProviderFactory factory = new DirectoryProviderFactory();
+		while ( iter.hasNext() ) {
+			PersistentClass clazz = (PersistentClass) iter.next();
+			Class<?> mappedClass = clazz.getMappedClass();
+			if ( mappedClass != null ) {
+				XClass mappedXClass = reflectionManager.toXClass( mappedClass );
+				if ( mappedXClass != null && mappedXClass.isAnnotationPresent( Indexed.class ) ) {
+					DirectoryProvider provider = factory.createDirectoryProvider( mappedXClass, cfg );
+					if ( !lockableDirectoryProviders.containsKey( provider ) ) {
+						lockableDirectoryProviders.put( provider, new ReentrantLock() );
+					}
+					final DocumentBuilder<Object> documentBuilder = new DocumentBuilder<Object>(
+							mappedXClass, analyzer, provider, reflectionManager
+					);
+
+					documentBuilders.put( mappedClass, documentBuilder );
+				}
+			}
+		}
+		Set<Class> indexedClasses = documentBuilders.keySet();
+		for ( DocumentBuilder builder : documentBuilders.values() ) {
+			builder.postInitialize( indexedClasses );
+		}
+		initialized = true;
+	}
+
+	public void onPostDelete(PostDeleteEvent event) {
+		if ( documentBuilders.containsKey( event.getEntity().getClass() ) ) {
+			DeleteWork work = new DeleteWork( event.getId(), event.getEntity().getClass() );
+			processWork( work, event );
+		}
+	}
+
+	public void onPostInsert(PostInsertEvent event) {
+		final Object entity = event.getEntity();
+		DocumentBuilder<Object> builder = documentBuilders.get( entity.getClass() );
+		if ( builder != null ) {
+			Serializable id = event.getId();
+			Document doc = builder.getDocument( entity, id );
+			AddWork work = new AddWork( id, entity.getClass(), doc );
+			processWork( work, event );
+		}
+	}
+
+	public void onPostUpdate(PostUpdateEvent event) {
+		final Object entity = event.getEntity();
+		DocumentBuilder<Object> builder = documentBuilders.get( entity.getClass() );
+		if ( builder != null ) {
+			Serializable id = event.getId();
+			Document doc = builder.getDocument( entity, id );
+			UpdateWork work = new UpdateWork( id, entity.getClass(), doc );
+			processWork( work, event );
+		}
+	}
+
+	private void processWork(Work work, AbstractEvent event) {
+		WorkQueue workQueue = new BatchLuceneWorkQueue( documentBuilders, lockableDirectoryProviders );
+		workQueue.add( work );
+		PostTransactionWorkQueueSynchronization sync = new PostTransactionWorkQueueSynchronization( workQueue );
+		if ( event.getSession().isTransactionInProgress() ) {
+			event.getSession().getTransaction().registerSynchronization( sync );
+		}
+		else {
+			sync.afterCompletion( Status.STATUS_COMMITTED );
+		}
+	}
+
+	public Map<DirectoryProvider, ReentrantLock> getLockableDirectoryProviders() {
+		return lockableDirectoryProviders;
+	}
+}


Property changes on: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextEventListener.java
___________________________________________________________________
Name: svn:executable
   + *
Name: svn:keywords
   + Author Date Id Revision
Name: svn:eol-style
   + native

Deleted: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/LuceneEventListener.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/LuceneEventListener.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/event/LuceneEventListener.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -1,180 +0,0 @@
-//$Id$
-package org.hibernate.search.event;
-
-import java.io.Serializable;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.locks.ReentrantLock;
-import javax.transaction.Status;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.apache.lucene.analysis.Analyzer;
-import org.apache.lucene.analysis.standard.StandardAnalyzer;
-import org.apache.lucene.document.Document;
-import org.hibernate.HibernateException;
-import org.hibernate.cfg.AnnotationConfiguration;
-import org.hibernate.cfg.Configuration;
-import org.hibernate.event.AbstractEvent;
-import org.hibernate.event.Initializable;
-import org.hibernate.event.PostDeleteEvent;
-import org.hibernate.event.PostDeleteEventListener;
-import org.hibernate.event.PostInsertEvent;
-import org.hibernate.event.PostInsertEventListener;
-import org.hibernate.event.PostUpdateEvent;
-import org.hibernate.event.PostUpdateEventListener;
-import org.hibernate.search.Environment;
-import org.hibernate.search.annotations.Indexed;
-import org.hibernate.search.backend.AddWork;
-import org.hibernate.search.backend.DeleteWork;
-import org.hibernate.search.backend.UpdateWork;
-import org.hibernate.search.backend.Work;
-import org.hibernate.search.backend.WorkQueue;
-import org.hibernate.search.backend.impl.BatchLuceneWorkQueue;
-import org.hibernate.search.backend.impl.PostTransactionWorkQueueSynchronization;
-import org.hibernate.search.engine.DocumentBuilder;
-import org.hibernate.search.store.DirectoryProvider;
-import org.hibernate.search.store.DirectoryProviderFactory;
-import org.hibernate.mapping.PersistentClass;
-import org.hibernate.reflection.ReflectionManager;
-import org.hibernate.reflection.XClass;
-import org.hibernate.util.ReflectHelper;
-
-/**
- * This listener supports setting a parent directory for all generated index files.
- * It also supports setting the analyzer class to be used.
- *
- * @author Gavin King
- * @author Emmanuel Bernard
- * @author Mattias Arbin
- */
-//TODO work on sharing the same indexWriters and readers across a single post operation...
-//TODO implement and use a LockableDirectoryProvider that wraps a DP to handle the lock inside the LDP
-public class LuceneEventListener implements PostDeleteEventListener, PostInsertEventListener,
-		PostUpdateEventListener, Initializable {
-	ReflectionManager reflectionManager;
-
-	//FIXME keeping this here is a bad decision since you might want to search indexes wo maintain it
-	@Deprecated
-	public Map<Class, DocumentBuilder<Object>> getDocumentBuilders() {
-		return documentBuilders;
-	}
-
-
-	private Map<Class, DocumentBuilder<Object>> documentBuilders = new HashMap<Class, DocumentBuilder<Object>>();
-	//keep track of the index modifiers per DirectoryProvider since multiple entity can use the same directory provider
-	private Map<DirectoryProvider, ReentrantLock> lockableDirectoryProviders =
-			new HashMap<DirectoryProvider, ReentrantLock>();
-	private boolean initialized;
-
-	private static final Log log = LogFactory.getLog( LuceneEventListener.class );
-
-	public void initialize(Configuration cfg) {
-		if ( initialized ) return;
-		//yuk
-		reflectionManager = ( (AnnotationConfiguration) cfg ).createExtendedMappings().getReflectionManager();
-
-		Class analyzerClass;
-		String analyzerClassName = cfg.getProperty( Environment.ANALYZER_CLASS );
-		if ( analyzerClassName != null ) {
-			try {
-				analyzerClass = ReflectHelper.classForName( analyzerClassName );
-			}
-			catch (Exception e) {
-				throw new HibernateException(
-						"Lucene analyzer class '" + analyzerClassName + "' defined in property '" + Environment.ANALYZER_CLASS + "' could not be found.",
-						e
-				);
-			}
-		}
-		else {
-			analyzerClass = StandardAnalyzer.class;
-		}
-		// Initialize analyzer
-		Analyzer analyzer;
-		try {
-			analyzer = (Analyzer) analyzerClass.newInstance();
-		}
-		catch (ClassCastException e) {
-			throw new HibernateException(
-					"Lucene analyzer does not implement " + Analyzer.class.getName() + ": " + analyzerClassName
-			);
-		}
-		catch (Exception e) {
-			throw new HibernateException( "Failed to instantiate lucene analyzer with type " + analyzerClassName );
-		}
-
-		Iterator iter = cfg.getClassMappings();
-		DirectoryProviderFactory factory = new DirectoryProviderFactory();
-		while ( iter.hasNext() ) {
-			PersistentClass clazz = (PersistentClass) iter.next();
-			Class<?> mappedClass = clazz.getMappedClass();
-			if ( mappedClass != null ) {
-				XClass mappedXClass = reflectionManager.toXClass( mappedClass );
-				if ( mappedXClass != null && mappedXClass.isAnnotationPresent( Indexed.class ) ) {
-					DirectoryProvider provider = factory.createDirectoryProvider( mappedXClass, cfg );
-					if ( !lockableDirectoryProviders.containsKey( provider ) ) {
-						lockableDirectoryProviders.put( provider, new ReentrantLock() );
-					}
-					final DocumentBuilder<Object> documentBuilder = new DocumentBuilder<Object>(
-							mappedXClass, analyzer, provider, reflectionManager
-					);
-
-					documentBuilders.put( mappedClass, documentBuilder );
-				}
-			}
-		}
-		Set<Class> indexedClasses = documentBuilders.keySet();
-		for ( DocumentBuilder builder : documentBuilders.values() ) {
-			builder.postInitialize( indexedClasses );
-		}
-		initialized = true;
-	}
-
-	public void onPostDelete(PostDeleteEvent event) {
-		if ( documentBuilders.containsKey( event.getEntity().getClass() ) ) {
-			DeleteWork work = new DeleteWork( event.getId(), event.getEntity().getClass() );
-			processWork( work, event );
-		}
-	}
-
-	public void onPostInsert(PostInsertEvent event) {
-		final Object entity = event.getEntity();
-		DocumentBuilder<Object> builder = documentBuilders.get( entity.getClass() );
-		if ( builder != null ) {
-			Serializable id = event.getId();
-			Document doc = builder.getDocument( entity, id );
-			AddWork work = new AddWork( id, entity.getClass(), doc );
-			processWork( work, event );
-		}
-	}
-
-	public void onPostUpdate(PostUpdateEvent event) {
-		final Object entity = event.getEntity();
-		DocumentBuilder<Object> builder = documentBuilders.get( entity.getClass() );
-		if ( builder != null ) {
-			Serializable id = event.getId();
-			Document doc = builder.getDocument( entity, id );
-			UpdateWork work = new UpdateWork( id, entity.getClass(), doc );
-			processWork( work, event );
-		}
-	}
-
-	private void processWork(Work work, AbstractEvent event) {
-		WorkQueue workQueue = new BatchLuceneWorkQueue( documentBuilders, lockableDirectoryProviders );
-		workQueue.add( work );
-		PostTransactionWorkQueueSynchronization sync = new PostTransactionWorkQueueSynchronization( workQueue );
-		if ( event.getSession().isTransactionInProgress() ) {
-			event.getSession().getTransaction().registerSynchronization( sync );
-		}
-		else {
-			sync.afterCompletion( Status.STATUS_COMMITTED );
-		}
-	}
-
-	public Map<DirectoryProvider, ReentrantLock> getLockableDirectoryProviders() {
-		return lockableDirectoryProviders;
-	}
-}

Copied: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/FullTextQueryImpl.java (from rev 10742, branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/LuceneQueryImpl.java)
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/LuceneQueryImpl.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/FullTextQueryImpl.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -0,0 +1,296 @@
+//$Id: $
+package org.hibernate.search.query;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.Hits;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.MultiSearcher;
+import org.apache.lucene.search.Searcher;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.store.Directory;
+import org.hibernate.Hibernate;
+import org.hibernate.HibernateException;
+import org.hibernate.LockMode;
+import org.hibernate.Query;
+import org.hibernate.ScrollMode;
+import org.hibernate.ScrollableResults;
+import org.hibernate.Session;
+import org.hibernate.engine.SessionImplementor;
+import org.hibernate.engine.query.ParameterMetadata;
+import org.hibernate.impl.AbstractQueryImpl;
+import org.hibernate.search.engine.DocumentBuilder;
+import org.hibernate.search.event.FullTextEventListener;
+import org.hibernate.search.util.ContextHelper;
+
+/**
+ * @author Emmanuel Bernard
+ */
+//TODO implements setParameter()
+public class FullTextQueryImpl extends AbstractQueryImpl {
+	private static final Log log = LogFactory.getLog( FullTextQueryImpl.class );
+	private org.apache.lucene.search.Query luceneQuery;
+	private Class[] classes;
+	private Set<Class> classesAndSubclasses;
+	private Integer firstResult;
+	private Integer maxResults;
+	private int resultSize;
+
+	/**
+	 * classes must be immutable
+	 */
+	public FullTextQueryImpl(org.apache.lucene.search.Query query, Class[] classes, SessionImplementor session,
+						   ParameterMetadata parameterMetadata) {
+		//TODO handle flushMode
+		super( query.toString(), null, session, parameterMetadata );
+		this.luceneQuery = query;
+		this.classes = classes;
+	}
+
+	/**
+	 * Return an interator on the results.
+	 * Retrieve the object one by one (initialize it during the next() operation)
+	 */
+	public Iterator iterate() throws HibernateException {
+		//implement an interator which keep the id/class for each hit and get the object on demand
+		//cause I can't keep the searcher and hence the hit opened. I dont have any hook to know when the
+		//user stop using it
+		//scrollable is better in this area
+
+		FullTextEventListener listener = ContextHelper.getLuceneEventListener( session );
+		//find the directories
+		Searcher searcher = buildSearcher( listener );
+		try {
+			org.apache.lucene.search.Query query = filterQueryByClasses( luceneQuery );
+			Hits hits = searcher.search( query );
+			setResultSize( hits );
+			int first = first();
+			int max = max( first, hits );
+			List<EntityInfo> entityInfos = new ArrayList<EntityInfo>( max - first + 1 );
+			for ( int index = first; index <= max; index++ ) {
+				Document document = hits.doc( index );
+				EntityInfo entityInfo = new EntityInfo();
+				entityInfo.clazz = DocumentBuilder.getDocumentClass( document );
+				entityInfo.id = DocumentBuilder.getDocumentId( listener, entityInfo.clazz, document );
+				entityInfos.add( entityInfo );
+			}
+			return new IteratorImpl( entityInfos, (Session) this.session );
+		}
+		catch (IOException e) {
+			throw new HibernateException( "Unable to query Lucene index", e );
+		}
+		finally {
+			if ( searcher != null ) try {
+				searcher.close();
+			}
+			catch (IOException e) {
+				log.warn( "Unable to properly close searcher during lucene query: " + getQueryString(), e );
+			}
+		}
+	}
+
+	public ScrollableResults scroll() throws HibernateException {
+		//keep the searcher open until the resultset is closed
+		FullTextEventListener listener = ContextHelper.getLuceneEventListener( session );;
+		//find the directories
+		Searcher searcher = buildSearcher( listener );
+		Hits hits;
+		try {
+			org.apache.lucene.search.Query query = filterQueryByClasses( luceneQuery );
+			hits = searcher.search( query );
+			setResultSize( hits );
+			int first = first();
+			int max = max( first, hits );
+			return new ScrollableResultsImpl( searcher, hits, first, max, (Session) this.session, listener );
+		}
+		catch (IOException e) {
+			try {
+				if ( searcher != null ) searcher.close();
+			}
+			catch (IOException ee) {
+				//we have the initial issue already
+			}
+			throw new HibernateException( "Unable to query Lucene index", e );
+		}
+	}
+
+	public ScrollableResults scroll(ScrollMode scrollMode) throws HibernateException {
+		//TODO think about this scrollmode
+		return scroll();
+	}
+
+	public List list() throws HibernateException {
+		FullTextEventListener listener = ContextHelper.getLuceneEventListener( session );;
+		//find the directories
+		Searcher searcher = buildSearcher( listener );
+		Hits hits;
+		try {
+			org.apache.lucene.search.Query query = filterQueryByClasses( luceneQuery );
+			hits = searcher.search( query );
+			setResultSize( hits );
+			int first = first();
+			int max = max( first, hits );
+			List result = new ArrayList( max - first + 1 );
+			Session sess = (Session) this.session;
+			for ( int index = first; index <= max; index++ ) {
+				Document document = hits.doc( index );
+				Class clazz = DocumentBuilder.getDocumentClass( document );
+				Serializable id = DocumentBuilder.getDocumentId( listener, clazz, document );
+				result.add( sess.load( clazz, id ) );
+				//use load to benefit from the batch-size
+				//we don't face proxy casting issues since the exact class is extracted from the index
+			}
+			//then initialize the objects
+			for ( Object element : result ) {
+				Hibernate.initialize( element );
+			}
+			return result;
+		}
+		catch (IOException e) {
+			throw new HibernateException( "Unable to query Lucene index", e );
+		}
+		finally {
+			if ( searcher != null ) try {
+				searcher.close();
+			}
+			catch (IOException e) {
+				log.warn( "Unable to properly close searcher during lucene query: " + getQueryString(), e );
+			}
+		}
+	}
+
+	private org.apache.lucene.search.Query filterQueryByClasses(org.apache.lucene.search.Query luceneQuery) {
+		//A query filter is more practical than a manual class filtering post query (esp on scrollable resultsets)
+		//it also probably minimise the memory footprint
+		if ( classesAndSubclasses == null ) {
+			return luceneQuery;
+		}
+		else {
+			BooleanQuery classFilter = new BooleanQuery();
+			//annihilate the scoring impact of DocumentBuilder.CLASS_FIELDNAME
+			classFilter.setBoost( 0 );
+			for ( Class clazz : classesAndSubclasses ) {
+				Term t = new Term( DocumentBuilder.CLASS_FIELDNAME, clazz.getName() );
+				TermQuery termQuery = new TermQuery( t );
+				classFilter.add( termQuery, BooleanClause.Occur.SHOULD );
+			}
+			BooleanQuery filteredQuery = new BooleanQuery();
+			filteredQuery.add( luceneQuery, BooleanClause.Occur.MUST );
+			filteredQuery.add( classFilter, BooleanClause.Occur.MUST );
+			return filteredQuery;
+		}
+	}
+
+	private int max(int first, Hits hits) {
+		return maxResults == null ?
+				hits.length() - 1 :
+				maxResults + first < hits.length() ?
+						first + maxResults - 1 :
+						hits.length() - 1;
+	}
+
+	private int first() {
+		return firstResult != null ?
+				firstResult :
+				0;
+	}
+
+	//TODO change classesAndSubclasses by side effect, which is a mismatch with the Searcher return, fix that.
+	private Searcher buildSearcher(FullTextEventListener listener) {
+		Map<Class, DocumentBuilder<Object>> builders = listener.getDocumentBuilders();
+		Set<Directory> directories = new HashSet<Directory>();
+		if ( classes == null || classes.length == 0 ) {
+			//no class means all classes
+			for ( DocumentBuilder builder : builders.values() ) {
+				directories.add( builder.getDirectoryProvider().getDirectory() );
+			}
+			classesAndSubclasses = null;
+		}
+		else {
+			Set<Class> involvedClasses = new HashSet<Class>( classes.length );
+			Collections.addAll( involvedClasses, classes );
+			for ( Class clazz : classes ) {
+				DocumentBuilder builder = builders.get( clazz );
+				if ( builder != null ) involvedClasses.addAll( builder.getMappedSubclasses() );
+			}
+			for ( Class clazz : involvedClasses ) {
+				DocumentBuilder builder = builders.get( clazz );
+				//TODO should we rather choose a polymorphic path and allow non mapped entities
+				if ( builder == null ) throw new HibernateException( "Not a mapped entity: " + clazz );
+				directories.add( builder.getDirectoryProvider().getDirectory() );
+			}
+			classesAndSubclasses = involvedClasses;
+		}
+
+		//set up the searcher
+		Searcher searcher;
+		int dirNbr = directories.size();
+		if ( dirNbr > 1 ) {
+			try {
+				IndexSearcher[] searchers = new IndexSearcher[dirNbr];
+				Iterator<Directory> it = directories.iterator();
+				for ( int index = 0; index < dirNbr; index++ ) {
+					searchers[index] = new IndexSearcher( it.next() );
+				}
+				searcher = new MultiSearcher( searchers );
+			}
+			catch (IOException e) {
+				throw new HibernateException( "Unable to read Lucene directory", e );
+			}
+		}
+		else {
+			try {
+				searcher = new IndexSearcher( directories.iterator().next() );
+			}
+			catch (IOException e) {
+				throw new HibernateException( "Unable to read Lucene directory", e );
+			}
+		}
+		return searcher;
+	}
+
+	private void setResultSize(Hits hits) {
+		resultSize = hits.length();
+	}
+
+	//FIXME does it make sense
+	public int resultSize() {
+		return this.resultSize;
+	}
+
+	public Query setFirstResult(int firstResult) {
+		this.firstResult = firstResult;
+		return this;
+	}
+
+	public Query setMaxResults(int maxResults) {
+		this.maxResults = maxResults;
+		return this;
+	}
+
+	public int executeUpdate() throws HibernateException {
+		throw new HibernateException( "Not supported operation" );
+	}
+
+	public Query setLockMode(String alias, LockMode lockMode) {
+		return null;
+	}
+
+	protected Map getLockModes() {
+		return null;
+	}
+}

Deleted: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/LuceneQueryImpl.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/LuceneQueryImpl.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/LuceneQueryImpl.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -1,297 +0,0 @@
-//$Id: $
-package org.hibernate.search.query;
-
-import java.io.IOException;
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.index.Term;
-import org.apache.lucene.search.BooleanClause;
-import org.apache.lucene.search.BooleanQuery;
-import org.apache.lucene.search.Hits;
-import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.MultiSearcher;
-import org.apache.lucene.search.Searcher;
-import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.store.Directory;
-import org.hibernate.Hibernate;
-import org.hibernate.HibernateException;
-import org.hibernate.LockMode;
-import org.hibernate.Query;
-import org.hibernate.ScrollMode;
-import org.hibernate.ScrollableResults;
-import org.hibernate.Session;
-import org.hibernate.engine.SessionImplementor;
-import org.hibernate.engine.query.ParameterMetadata;
-import org.hibernate.event.PostInsertEventListener;
-import org.hibernate.impl.AbstractQueryImpl;
-import org.hibernate.search.engine.DocumentBuilder;
-import org.hibernate.search.event.LuceneEventListener;
-import org.hibernate.search.util.ContextHelper;
-
-/**
- * @author Emmanuel Bernard
- */
-//implements setParameter()
-public class LuceneQueryImpl extends AbstractQueryImpl {
-	private static final Log log = LogFactory.getLog( LuceneQueryImpl.class );
-	private org.apache.lucene.search.Query luceneQuery;
-	private Class[] classes;
-	private Set<Class> classesAndSubclasses;
-	private Integer firstResult;
-	private Integer maxResults;
-	private int resultSize;
-
-	/**
-	 * classes must be immutable
-	 */
-	public LuceneQueryImpl(org.apache.lucene.search.Query query, Class[] classes, SessionImplementor session,
-						   ParameterMetadata parameterMetadata) {
-		//TODO handle flushMode
-		super( query.toString(), null, session, parameterMetadata );
-		this.luceneQuery = query;
-		this.classes = classes;
-	}
-
-	/**
-	 * Return an interator on the results.
-	 * Retrieve the object one by one (initialize it during the next() operation)
-	 */
-	public Iterator iterate() throws HibernateException {
-		//implement an interator which keep the id/class for each hit and get the object on demand
-		//cause I can't keep the searcher and hence the hit opened. I dont have any hook to know when the
-		//user stop using it
-		//scrollable is better in this area
-
-		LuceneEventListener listener = ContextHelper.getLuceneEventListener( session );
-		//find the directories
-		Searcher searcher = buildSearcher( listener );
-		try {
-			org.apache.lucene.search.Query query = filterQueryByClasses( luceneQuery );
-			Hits hits = searcher.search( query );
-			setResultSize( hits );
-			int first = first();
-			int max = max( first, hits );
-			List<EntityInfo> entityInfos = new ArrayList<EntityInfo>( max - first + 1 );
-			for ( int index = first; index <= max; index++ ) {
-				Document document = hits.doc( index );
-				EntityInfo entityInfo = new EntityInfo();
-				entityInfo.clazz = DocumentBuilder.getDocumentClass( document );
-				entityInfo.id = DocumentBuilder.getDocumentId( listener, entityInfo.clazz, document );
-				entityInfos.add( entityInfo );
-			}
-			return new IteratorImpl( entityInfos, (Session) this.session );
-		}
-		catch (IOException e) {
-			throw new HibernateException( "Unable to query Lucene index", e );
-		}
-		finally {
-			if ( searcher != null ) try {
-				searcher.close();
-			}
-			catch (IOException e) {
-				log.warn( "Unable to properly close searcher during lucene query: " + getQueryString(), e );
-			}
-		}
-	}
-
-	public ScrollableResults scroll() throws HibernateException {
-		//keep the searcher open until the resultset is closed
-		LuceneEventListener listener = ContextHelper.getLuceneEventListener( session );;
-		//find the directories
-		Searcher searcher = buildSearcher( listener );
-		Hits hits;
-		try {
-			org.apache.lucene.search.Query query = filterQueryByClasses( luceneQuery );
-			hits = searcher.search( query );
-			setResultSize( hits );
-			int first = first();
-			int max = max( first, hits );
-			return new ScrollableResultsImpl( searcher, hits, first, max, (Session) this.session, listener );
-		}
-		catch (IOException e) {
-			try {
-				if ( searcher != null ) searcher.close();
-			}
-			catch (IOException ee) {
-				//we have the initial issue already
-			}
-			throw new HibernateException( "Unable to query Lucene index", e );
-		}
-	}
-
-	public ScrollableResults scroll(ScrollMode scrollMode) throws HibernateException {
-		//TODO think about this scrollmode
-		return scroll();
-	}
-
-	public List list() throws HibernateException {
-		LuceneEventListener listener = ContextHelper.getLuceneEventListener( session );;
-		//find the directories
-		Searcher searcher = buildSearcher( listener );
-		Hits hits;
-		try {
-			org.apache.lucene.search.Query query = filterQueryByClasses( luceneQuery );
-			hits = searcher.search( query );
-			setResultSize( hits );
-			int first = first();
-			int max = max( first, hits );
-			List result = new ArrayList( max - first + 1 );
-			Session sess = (Session) this.session;
-			for ( int index = first; index <= max; index++ ) {
-				Document document = hits.doc( index );
-				Class clazz = DocumentBuilder.getDocumentClass( document );
-				Serializable id = DocumentBuilder.getDocumentId( listener, clazz, document );
-				result.add( sess.load( clazz, id ) );
-				//use load to benefit from the batch-size
-				//we don't face proxy casting issues since the exact class is extracted from the index
-			}
-			//then initialize the objects
-			for ( Object element : result ) {
-				Hibernate.initialize( element );
-			}
-			return result;
-		}
-		catch (IOException e) {
-			throw new HibernateException( "Unable to query Lucene index", e );
-		}
-		finally {
-			if ( searcher != null ) try {
-				searcher.close();
-			}
-			catch (IOException e) {
-				log.warn( "Unable to properly close searcher during lucene query: " + getQueryString(), e );
-			}
-		}
-	}
-
-	private org.apache.lucene.search.Query filterQueryByClasses(org.apache.lucene.search.Query luceneQuery) {
-		//A query filter is more practical than a manual class filtering post query (esp on scrollable resultsets)
-		//it also probably minimise the memory footprint
-		if ( classesAndSubclasses == null ) {
-			return luceneQuery;
-		}
-		else {
-			BooleanQuery classFilter = new BooleanQuery();
-			//annihilate the scoring impact of DocumentBuilder.CLASS_FIELDNAME
-			classFilter.setBoost( 0 );
-			for ( Class clazz : classesAndSubclasses ) {
-				Term t = new Term( DocumentBuilder.CLASS_FIELDNAME, clazz.getName() );
-				TermQuery termQuery = new TermQuery( t );
-				classFilter.add( termQuery, BooleanClause.Occur.SHOULD );
-			}
-			BooleanQuery filteredQuery = new BooleanQuery();
-			filteredQuery.add( luceneQuery, BooleanClause.Occur.MUST );
-			filteredQuery.add( classFilter, BooleanClause.Occur.MUST );
-			return filteredQuery;
-		}
-	}
-
-	private int max(int first, Hits hits) {
-		return maxResults == null ?
-				hits.length() - 1 :
-				maxResults + first < hits.length() ?
-						first + maxResults - 1 :
-						hits.length() - 1;
-	}
-
-	private int first() {
-		return firstResult != null ?
-				firstResult :
-				0;
-	}
-
-	//TODO change classesAndSubclasses by side effect, which is a mismatch with the Searcher return, fix that.
-	private Searcher buildSearcher(LuceneEventListener listener) {
-		Map<Class, DocumentBuilder<Object>> builders = listener.getDocumentBuilders();
-		Set<Directory> directories = new HashSet<Directory>();
-		if ( classes == null || classes.length == 0 ) {
-			//no class means all classes
-			for ( DocumentBuilder builder : builders.values() ) {
-				directories.add( builder.getDirectoryProvider().getDirectory() );
-			}
-			classesAndSubclasses = null;
-		}
-		else {
-			Set<Class> involvedClasses = new HashSet<Class>( classes.length );
-			Collections.addAll( involvedClasses, classes );
-			for ( Class clazz : classes ) {
-				DocumentBuilder builder = builders.get( clazz );
-				if ( builder != null ) involvedClasses.addAll( builder.getMappedSubclasses() );
-			}
-			for ( Class clazz : involvedClasses ) {
-				DocumentBuilder builder = builders.get( clazz );
-				//TODO should we rather choose a polymorphic path and allow non mapped entities
-				if ( builder == null ) throw new HibernateException( "Not a mapped entity: " + clazz );
-				directories.add( builder.getDirectoryProvider().getDirectory() );
-			}
-			classesAndSubclasses = involvedClasses;
-		}
-
-		//set up the searcher
-		Searcher searcher;
-		int dirNbr = directories.size();
-		if ( dirNbr > 1 ) {
-			try {
-				IndexSearcher[] searchers = new IndexSearcher[dirNbr];
-				Iterator<Directory> it = directories.iterator();
-				for ( int index = 0; index < dirNbr; index++ ) {
-					searchers[index] = new IndexSearcher( it.next() );
-				}
-				searcher = new MultiSearcher( searchers );
-			}
-			catch (IOException e) {
-				throw new HibernateException( "Unable to read Lucene directory", e );
-			}
-		}
-		else {
-			try {
-				searcher = new IndexSearcher( directories.iterator().next() );
-			}
-			catch (IOException e) {
-				throw new HibernateException( "Unable to read Lucene directory", e );
-			}
-		}
-		return searcher;
-	}
-
-	private void setResultSize(Hits hits) {
-		resultSize = hits.length();
-	}
-
-	//FIXME does it make sense
-	public int resultSize() {
-		return this.resultSize;
-	}
-
-	public Query setFirstResult(int firstResult) {
-		this.firstResult = firstResult;
-		return this;
-	}
-
-	public Query setMaxResults(int maxResults) {
-		this.maxResults = maxResults;
-		return this;
-	}
-
-	public int executeUpdate() throws HibernateException {
-		throw new HibernateException( "Not supported operation" );
-	}
-
-	public Query setLockMode(String alias, LockMode lockMode) {
-		return null;
-	}
-
-	protected Map getLockModes() {
-		return null;
-	}
-}

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/ScrollableResultsImpl.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/ScrollableResultsImpl.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/query/ScrollableResultsImpl.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -18,7 +18,7 @@
 import org.hibernate.ScrollableResults;
 import org.hibernate.Session;
 import org.hibernate.search.engine.DocumentBuilder;
-import org.hibernate.search.event.LuceneEventListener;
+import org.hibernate.search.event.FullTextEventListener;
 import org.hibernate.type.Type;
 
 /**
@@ -31,11 +31,11 @@
 	private final int max;
 	private int current;
 	private final Session session;
-	private final LuceneEventListener listener;
+	private final FullTextEventListener listener;
 	private EntityInfo[] entityInfos;
 
 	public ScrollableResultsImpl(
-			Searcher searcher, Hits hits, int first, int max, Session session, LuceneEventListener listener
+			Searcher searcher, Hits hits, int first, int max, Session session, FullTextEventListener listener
 	) {
 		this.searcher = searcher;
 		this.hits = hits;

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/util/ContextHelper.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/util/ContextHelper.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/java/org/hibernate/search/util/ContextHelper.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -4,20 +4,20 @@
 import org.hibernate.HibernateException;
 import org.hibernate.engine.SessionImplementor;
 import org.hibernate.event.PostInsertEventListener;
-import org.hibernate.search.event.LuceneEventListener;
+import org.hibernate.search.event.FullTextEventListener;
 
 /**
  * @author Emmanuel Bernard
  */
 public abstract class ContextHelper {
 
-	public static LuceneEventListener getLuceneEventListener(SessionImplementor session) {
+	public static FullTextEventListener getLuceneEventListener(SessionImplementor session) {
 		PostInsertEventListener[] listeners = session.getListeners().getPostInsertEventListeners();
-		LuceneEventListener listener = null;
+		FullTextEventListener listener = null;
 		//FIXME this sucks since we mandante the event listener use
 		for ( PostInsertEventListener candidate : listeners ) {
-			if ( candidate instanceof LuceneEventListener ) {
-				listener = (LuceneEventListener) candidate;
+			if ( candidate instanceof FullTextEventListener ) {
+				listener = (FullTextEventListener) candidate;
 				break;
 			}
 		}

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/FSDirectoryTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/FSDirectoryTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/FSDirectoryTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -19,7 +19,7 @@
 import org.hibernate.event.PostUpdateEventListener;
 import org.hibernate.search.Environment;
 import org.hibernate.search.store.FSDirectoryProvider;
-import org.hibernate.search.event.LuceneEventListener;
+import org.hibernate.search.event.FullTextEventListener;
 
 /**
  * @author Gavin King
@@ -183,7 +183,7 @@
 		cfg.setProperty( "hibernate.search.default.indexBase", sub.getAbsolutePath() );
 		cfg.setProperty( "hibernate.search.Clock.directory_provider", FSDirectoryProvider.class.getName() );
 		cfg.setProperty( Environment.ANALYZER_CLASS, StopAnalyzer.class.getName() );
-		LuceneEventListener del = new LuceneEventListener();
+		FullTextEventListener del = new FullTextEventListener();
 		cfg.getEventListeners().setPostDeleteEventListeners( new PostDeleteEventListener[]{del} );
 		cfg.getEventListeners().setPostUpdateEventListeners( new PostUpdateEventListener[]{del} );
 		cfg.getEventListeners().setPostInsertEventListeners( new PostInsertEventListener[]{del} );

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TestCase.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TestCase.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TestCase.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -8,12 +8,9 @@
 import org.hibernate.event.PostUpdateEventListener;
 import org.hibernate.search.Environment;
 import org.hibernate.search.store.RAMDirectoryProvider;
-import org.hibernate.search.event.LuceneEventListener;
+import org.hibernate.search.event.FullTextEventListener;
 import org.hibernate.HibernateException;
-import org.hibernate.SessionFactory;
 import org.hibernate.impl.SessionFactoryImpl;
-import org.hibernate.engine.SessionImplementor;
-import org.hibernate.engine.SessionFactoryImplementor;
 
 /**
  * @author Emmanuel Bernard
@@ -28,13 +25,13 @@
 		return getLuceneEventListener().getDocumentBuilders().get( clazz ).getDirectoryProvider().getDirectory();
 	}
 
-	private LuceneEventListener getLuceneEventListener() {
+	private FullTextEventListener getLuceneEventListener() {
         PostInsertEventListener[] listeners = ( (SessionFactoryImpl) getSessions() ).getEventListeners().getPostInsertEventListeners();
-        LuceneEventListener listener = null;
+        FullTextEventListener listener = null;
         //FIXME this sucks since we mandante the event listener use
         for (PostInsertEventListener candidate : listeners) {
-            if (candidate instanceof LuceneEventListener) {
-                listener = (LuceneEventListener) candidate;
+            if (candidate instanceof FullTextEventListener ) {
+                listener = (FullTextEventListener) candidate;
                 break;
             }
         }
@@ -45,7 +42,7 @@
 	protected void configure(org.hibernate.cfg.Configuration cfg) {
 		cfg.setProperty( "hibernate.search.default.directory_provider", RAMDirectoryProvider.class.getName() );
 		cfg.setProperty( Environment.ANALYZER_CLASS, StopAnalyzer.class.getName() );
-		LuceneEventListener del = new LuceneEventListener();
+		FullTextEventListener del = new FullTextEventListener();
 		cfg.getEventListeners().setPostDeleteEventListeners( new PostDeleteEventListener[]{del} );
 		cfg.getEventListeners().setPostUpdateEventListeners( new PostUpdateEventListener[]{del} );
 		cfg.getEventListeners().setPostInsertEventListeners( new PostInsertEventListener[]{del} );

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -1,21 +1,10 @@
 //$Id: $
 package org.hibernate.search.test;
 
-import java.io.File;
 import java.io.IOException;
 
 import org.hibernate.Session;
-import org.hibernate.HibernateException;
-import org.hibernate.event.PostInsertEventListener;
-import org.hibernate.search.LuceneSession;
-import org.hibernate.search.event.LuceneEventListener;
 import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.TermDocs;
-import org.apache.lucene.index.Term;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.queryParser.QueryParser;
-import org.apache.lucene.analysis.standard.StandardAnalyzer;
-import org.apache.lucene.store.Directory;
 
 /**
  * @author Emmanuel Bernard

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/bridge/BridgeTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/bridge/BridgeTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/bridge/BridgeTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -11,13 +11,11 @@
 import org.hibernate.cfg.Configuration;
 
 import org.hibernate.search.test.TestCase;
-import org.hibernate.search.LuceneSession;
+import org.hibernate.search.FullTextSession;
 import org.hibernate.search.Environment;
-import org.hsqldb.Session;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.queryParser.QueryParser;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
-import org.apache.lucene.analysis.StopAnalyzer;
 import org.apache.lucene.analysis.SimpleAnalyzer;
 
 /**
@@ -43,7 +41,7 @@
         tx.commit();
 
         tx = s.beginTransaction();
-        LuceneSession session = new LuceneSession(s);
+        FullTextSession session = new FullTextSession(s);
         QueryParser parser = new QueryParser("id", new StandardAnalyzer() );
         Query query;
         List result;
@@ -73,7 +71,7 @@
         tx.commit();
 
         tx = s.beginTransaction();
-        LuceneSession session = new LuceneSession(s);
+        FullTextSession session = new FullTextSession(s);
         QueryParser parser = new QueryParser("id", new SimpleAnalyzer() );
         Query query;
         List result;
@@ -115,7 +113,7 @@
         tx.commit();
 
         tx = s.beginTransaction();
-        LuceneSession session = new LuceneSession(s);
+        FullTextSession session = new FullTextSession(s);
         QueryParser parser = new QueryParser("id", new StandardAnalyzer() );
         Query query;
         List result;

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/fieldAccess/FieldAccessTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/fieldAccess/FieldAccessTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/fieldAccess/FieldAccessTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -4,7 +4,7 @@
 import java.util.List;
 
 import org.hibernate.search.test.TestCase;
-import org.hibernate.search.LuceneSession;
+import org.hibernate.search.FullTextSession;
 import org.hibernate.Session;
 import org.hibernate.Transaction;
 import org.apache.lucene.queryParser.QueryParser;
@@ -24,7 +24,7 @@
 
         s.clear();
 
-        LuceneSession session = new LuceneSession(s);
+        FullTextSession session = new FullTextSession(s);
         tx = session.beginTransaction();
         QueryParser p = new QueryParser("id", new StandardAnalyzer( ) );
         List result = session.createLuceneQuery( p.parse( "Abstract:Hibernate" ) ).list();
@@ -48,7 +48,7 @@
 
         s.clear();
 
-        LuceneSession session = new LuceneSession(s);
+        FullTextSession session = new FullTextSession(s);
         tx = session.beginTransaction();
         QueryParser p = new QueryParser("id", new StandardAnalyzer( ) );
         List result = session.createLuceneQuery( p.parse( "title:Action OR Abstract:Action" ) ).list();

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/inheritance/InheritanceTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/inheritance/InheritanceTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/inheritance/InheritanceTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -2,18 +2,13 @@
 package org.hibernate.search.test.inheritance;
 
 import org.hibernate.search.test.TestCase;
-import org.hibernate.search.test.query.Clock;
-import org.hibernate.search.test.query.Book;
-import org.hibernate.search.LuceneSession;
+import org.hibernate.search.FullTextSession;
 import org.hibernate.Transaction;
-import org.hibernate.Hibernate;
-import org.hibernate.ScrollableResults;
 import org.apache.lucene.queryParser.QueryParser;
 import org.apache.lucene.analysis.StopAnalyzer;
 import org.apache.lucene.search.Query;
 
 import java.util.List;
-import java.util.Iterator;
 
 /**
  * @author Emmanuel Bernard
@@ -21,7 +16,7 @@
 public class InheritanceTest extends TestCase {
 
 	public void testInheritance() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		Animal a = new Animal();
         a.setName("Shark Jr");

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/query/LuceneQueryTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/query/LuceneQueryTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/query/LuceneQueryTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -5,7 +5,7 @@
 import java.util.Iterator;
 
 import org.hibernate.search.test.TestCase;
-import org.hibernate.search.LuceneSession;
+import org.hibernate.search.FullTextSession;
 import org.hibernate.Transaction;
 import org.hibernate.Hibernate;
 import org.hibernate.ScrollableResults;
@@ -20,7 +20,7 @@
 public class LuceneQueryTest extends TestCase {
 
 	public void testList() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		Clock clock = new Clock(1, "Seiko");
 		s.save( clock );
@@ -62,7 +62,7 @@
 	}
 
 	public void testFirstMax() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		Clock clock = new Clock(1, "Seiko");
 		s.save( clock );
@@ -108,7 +108,7 @@
 	}
 
 	public void testIterator() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		Clock clock = new Clock(1, "Seiko");
 		s.save( clock );
@@ -145,7 +145,7 @@
 	}
 
 	public void testScrollableResultSet() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		Clock clock = new Clock(1, "Seiko");
 		s.save( clock );
@@ -188,7 +188,7 @@
 	}
 
 	public void testMultipleEntityPerIndex() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		Clock clock = new Clock(1, "Seiko");
 		s.save( clock );

Modified: branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/session/MassIndexTest.java
===================================================================
--- branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/session/MassIndexTest.java	2006-11-07 01:03:16 UTC (rev 10742)
+++ branches/Lucene_Integration/HibernateExt/metadata/src/test/org/hibernate/search/test/session/MassIndexTest.java	2006-11-07 01:16:53 UTC (rev 10743)
@@ -1,12 +1,10 @@
 //$Id: $
 package org.hibernate.search.test.session;
 
-import java.sql.SQLException;
 import java.util.List;
 
 import org.hibernate.search.test.TestCase;
-import org.hibernate.search.LuceneSession;
-import org.hibernate.Session;
+import org.hibernate.search.FullTextSession;
 import org.hibernate.Transaction;
 import org.apache.lucene.queryParser.QueryParser;
 import org.apache.lucene.analysis.StopAnalyzer;
@@ -17,7 +15,7 @@
 public class MassIndexTest extends TestCase {
 
 	public void testTransactional() throws Exception {
-		LuceneSession s = new LuceneSession( openSession() );
+		FullTextSession s = new FullTextSession( openSession() );
 		Transaction tx = s.beginTransaction();
 		int loop = 4;
 		for (int i = 0 ; i < loop; i++) {
@@ -29,13 +27,13 @@
 		tx.commit();
 		s.close();
 
-		s = new LuceneSession( openSession() );
+		s = new FullTextSession( openSession() );
 		s.getTransaction().begin();
 		s.connection().createStatement().executeUpdate( "update Email set body='Meet the guys who write the software'");
 		s.getTransaction().commit();
 		s.close();
 
-		s = new LuceneSession( openSession() );
+		s = new FullTextSession( openSession() );
 		tx = s.beginTransaction();
 		QueryParser parser = new QueryParser("id", new StopAnalyzer() );
 		List result = s.createLuceneQuery( parser.parse( "body:write" ) ).list();
@@ -51,7 +49,7 @@
 		tx.commit(); //do the process
 		s.close();
 
-		s = new LuceneSession( openSession() );
+		s = new FullTextSession( openSession() );
 		tx = s.beginTransaction();
 		result = s.createLuceneQuery( parser.parse( "body:write" ) ).list();
 		assertEquals( loop, result.size() );