[hibernate-commits] Hibernate SVN: r10870 - in branches/Branch_3_2/HibernateExt/metadata/src: java/org/hibernate/search/backend/impl java/org/hibernate/search/event java/org/hibernate/search/impl java/org/hibernate/search/util test/org/hibernate/search/test
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Sun Nov 26 09:16:31 EST 2006
Author: epbernard
Date: 2006-11-26 09:16:21 -0500 (Sun, 26 Nov 2006)
New Revision: 10870
Added:
branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/util/WeakIdentityHashMap.java
Modified:
branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/backend/impl/PostTransactionWorkQueueSynchronization.java
branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextIndexEventListener.java
branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/impl/FullTextSessionImpl.java
branches/Branch_3_2/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java
Log:
ANN-497 one queue per transaction making operations faster.
Modified: branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/backend/impl/PostTransactionWorkQueueSynchronization.java
===================================================================
--- branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/backend/impl/PostTransactionWorkQueueSynchronization.java 2006-11-25 14:23:04 UTC (rev 10869)
+++ branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/backend/impl/PostTransactionWorkQueueSynchronization.java 2006-11-26 14:16:21 UTC (rev 10870)
@@ -6,6 +6,7 @@
import org.hibernate.search.backend.WorkQueue;
import org.hibernate.search.backend.Work;
+import org.hibernate.search.util.WeakIdentityHashMap;
/**
* Execute some work inside a transaction sychronization
@@ -15,11 +16,17 @@
public class PostTransactionWorkQueueSynchronization implements Synchronization {
private WorkQueue workQueue;
private boolean consumed;
+ private WeakIdentityHashMap queuePerTransaction;
public PostTransactionWorkQueueSynchronization(WorkQueue workQueue) {
this.workQueue = workQueue;
}
+ public PostTransactionWorkQueueSynchronization(WorkQueue workQueue, WeakIdentityHashMap queuePerTransaction) {
+ this(workQueue);
+ this.queuePerTransaction = queuePerTransaction;
+ }
+
public void add(Work work) {
workQueue.add( work );
}
@@ -42,6 +49,9 @@
}
finally {
consumed = true;
+ //clean the Synchronization per Transaction
+ //not needed stricto sensus but a cleaner approach and faster than the GC
+ if (queuePerTransaction != null) queuePerTransaction.removeValue( this );
}
}
}
Modified: branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextIndexEventListener.java
===================================================================
--- branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextIndexEventListener.java 2006-11-25 14:23:04 UTC (rev 10869)
+++ branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/event/FullTextIndexEventListener.java 2006-11-26 14:16:21 UTC (rev 10870)
@@ -6,6 +6,7 @@
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
+import java.util.WeakHashMap;
import java.util.concurrent.locks.ReentrantLock;
import javax.transaction.Status;
@@ -15,6 +16,7 @@
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.hibernate.HibernateException;
+import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import org.hibernate.event.AbstractEvent;
@@ -26,6 +28,7 @@
import org.hibernate.event.PostUpdateEvent;
import org.hibernate.event.PostUpdateEventListener;
import org.hibernate.search.Environment;
+import org.hibernate.search.util.WeakIdentityHashMap;
import org.hibernate.search.annotations.Indexed;
import org.hibernate.search.backend.AddWork;
import org.hibernate.search.backend.DeleteWork;
@@ -54,7 +57,9 @@
//TODO implement and use a LockableDirectoryProvider that wraps a DP to handle the lock inside the LDP
public class FullTextIndexEventListener implements PostDeleteEventListener, PostInsertEventListener,
PostUpdateEventListener, Initializable {
- ReflectionManager reflectionManager;
+ protected ReflectionManager reflectionManager;
+ //not a synchronized map since for a given transaction, we have not concurrent access
+ protected WeakIdentityHashMap queuePerTransaction;
//FIXME keeping this here is a bad decision since you might want to search indexes wo maintain it
@Deprecated
@@ -75,6 +80,7 @@
if ( initialized ) return;
//yuk
reflectionManager = ( (AnnotationConfiguration) cfg ).createExtendedMappings().getReflectionManager();
+ queuePerTransaction = new WeakIdentityHashMap();
Class analyzerClass;
String analyzerClassName = cfg.getProperty( Environment.ANALYZER_CLASS );
@@ -163,13 +169,22 @@
}
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 );
+ Transaction transaction = event.getSession().getTransaction();
+ PostTransactionWorkQueueSynchronization sync = (PostTransactionWorkQueueSynchronization)
+ queuePerTransaction.get( transaction );
+ if ( sync == null || sync.isConsumed() ) {
+ WorkQueue workQueue = new BatchLuceneWorkQueue( documentBuilders, lockableDirectoryProviders );
+ sync = new PostTransactionWorkQueueSynchronization( workQueue, queuePerTransaction );
+ transaction.registerSynchronization( sync );
+ queuePerTransaction.put(transaction, sync);
+ }
+ sync.add( work );
}
else {
+ WorkQueue workQueue = new BatchLuceneWorkQueue( documentBuilders, lockableDirectoryProviders );
+ PostTransactionWorkQueueSynchronization sync = new PostTransactionWorkQueueSynchronization( workQueue );
+ sync.add( work );
sync.afterCompletion( Status.STATUS_COMMITTED );
}
}
Modified: branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/impl/FullTextSessionImpl.java
===================================================================
--- branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/impl/FullTextSessionImpl.java 2006-11-25 14:23:04 UTC (rev 10869)
+++ branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/impl/FullTextSessionImpl.java 2006-11-26 14:16:21 UTC (rev 10870)
@@ -213,6 +213,7 @@
}
public void clear() {
+ postTransactionWorkQueueSynch.afterCompletion( Status.STATUS_ROLLEDBACK );
session.clear();
}
Added: branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/util/WeakIdentityHashMap.java
===================================================================
--- branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/util/WeakIdentityHashMap.java 2006-11-25 14:23:04 UTC (rev 10869)
+++ branches/Branch_3_2/HibernateExt/metadata/src/java/org/hibernate/search/util/WeakIdentityHashMap.java 2006-11-26 14:16:21 UTC (rev 10870)
@@ -0,0 +1,1019 @@
+//$Id: $
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+
+package org.hibernate.search.util;
+
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.AbstractCollection;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+/**
+ * A hashtable-based <tt>Map</tt> implementation with <em>weak keys</em> and
+ * using reference-equality in place of object-equality when comparing keys
+ * (and values). In an <tt>WeakIdentityHashMap</tt>, two keys <tt>k1</tt> and
+ * <tt>k2</tt> are considered equal if and only if <tt>(k1==k2)</tt>.
+ * An entry in a <tt>WeakIdentityHashMap</tt> will automatically be removed when
+ * its key is no longer in ordinary use. More precisely, the presence of a
+ * mapping for a given key will not prevent the key from being discarded by the
+ * garbage collector, that is, made finalizable, finalized, and then reclaimed.
+ * When a key has been discarded its entry is effectively removed from the map.
+ * <p/>
+ * <p>Based on java.util.WeakHashMap</p>
+ * <p>Based on org.jboss.common.collection.WeakIdentityHashMap</p>
+ *
+ * @author Dawid Kurzyniec
+ * @author <a href="mailto:kabir.khan at jboss.org">Kabir Khan</a>
+ * @author Emmanuel Bernard
+
+ * @see java.util.IdentityHashMap
+ * @see java.util.WeakHashMap
+ */
+public class WeakIdentityHashMap /*extends AbstractMap*/ implements Map {
+
+ /**
+ * The default initial capacity -- MUST be a power of two.
+ */
+ private static final int DEFAULT_INITIAL_CAPACITY = 16;
+
+ /**
+ * The maximum capacity, used if a higher value is implicitly specified
+ * by either of the constructors with arguments.
+ * MUST be a power of two <= 1<<30.
+ */
+ private static final int MAXIMUM_CAPACITY = 1 << 30;
+
+ /**
+ * The load fast used when none specified in constructor.
+ */
+ private static final float DEFAULT_LOAD_FACTOR = 0.75f;
+
+ /**
+ * The table, resized as necessary. Length MUST Always be a power of two.
+ */
+ private Entry[] table;
+
+ /**
+ * The number of key-value mappings contained in this weak hash map.
+ */
+ private int size;
+
+ /**
+ * The next size value at which to resize (capacity * load factor).
+ */
+ private int threshold;
+
+ /**
+ * The load factor for the hash table.
+ */
+ private final float loadFactor;
+
+ /**
+ * Reference queue for cleared WeakEntries
+ */
+ private final ReferenceQueue queue = new ReferenceQueue();
+
+ /**
+ * The number of times this HashMap has been structurally modified
+ * Structural modifications are those that change the number of mappings in
+ * the HashMap or otherwise modify its internal structure (e.g.,
+ * rehash). This field is used to make iterators on Collection-views of
+ * the HashMap fail-fast. (See ConcurrentModificationException).
+ */
+ private volatile int modCount;
+
+ /**
+ * Each of these fields are initialized to contain an instance of the
+ * appropriate view the first time this view is requested. The views are
+ * stateless, so there's no reason to create more than one of each.
+ */
+ transient volatile Set keySet = null;
+ transient volatile Collection values = null;
+
+ /**
+ * Constructs a new, empty <tt>WeakIdentityHashMap</tt> with the given
+ * initial capacity and the given load factor.
+ *
+ * @param initialCapacity The initial capacity of the
+ * <tt>WeakIdentityHashMap</tt>
+ * @param loadFactor The load factor of the
+ * <tt>WeakIdentityHashMap</tt>
+ * @throws IllegalArgumentException If the initial capacity is negative,
+ * or if the load factor is nonpositive.
+ */
+ public WeakIdentityHashMap(int initialCapacity, float loadFactor) {
+ if ( initialCapacity < 0 )
+ throw new IllegalArgumentException( "Illegal Initial Capacity: " +
+ initialCapacity );
+ if ( initialCapacity > MAXIMUM_CAPACITY )
+ initialCapacity = MAXIMUM_CAPACITY;
+
+ if ( loadFactor <= 0 || Float.isNaN( loadFactor ) )
+ throw new IllegalArgumentException( "Illegal Load factor: " +
+ loadFactor );
+ int capacity = 1;
+ while ( capacity < initialCapacity )
+ capacity <<= 1;
+ table = new Entry[capacity];
+ this.loadFactor = loadFactor;
+ threshold = (int) ( capacity * loadFactor );
+ }
+
+ /**
+ * Constructs a new, empty <tt>WeakIdentityHashMap</tt> with the given
+ * initial capacity and the default load factor, which is <tt>0.75</tt>.
+ *
+ * @param initialCapacity The initial capacity of the
+ * <tt>WeakIdentityHashMap</tt>
+ * @throws IllegalArgumentException If the initial capacity is negative.
+ */
+ public WeakIdentityHashMap(int initialCapacity) {
+ this( initialCapacity, DEFAULT_LOAD_FACTOR );
+ }
+
+ /**
+ * Constructs a new, empty <tt>WeakIdentityHashMap</tt> with the default
+ * initial capacity (16) and the default load factor (0.75).
+ */
+ public WeakIdentityHashMap() {
+ this.loadFactor = DEFAULT_LOAD_FACTOR;
+ threshold = (int) ( DEFAULT_INITIAL_CAPACITY );
+ table = new Entry[DEFAULT_INITIAL_CAPACITY];
+ }
+
+ /**
+ * Constructs a new <tt>WeakIdentityHashMap</tt> with the same mappings as
+ * the specified <tt>Map</tt>. The <tt>WeakIdentityHashMap</tt> is created
+ * with default load factor, which is <tt>0.75</tt> and an initial capacity
+ * sufficient to hold the mappings in the specified <tt>Map</tt>.
+ *
+ * @param t the map whose mappings are to be placed in this map.
+ * @throws NullPointerException if the specified map is null.
+ */
+ public WeakIdentityHashMap(Map t) {
+ this( Math.max( (int) ( t.size() / DEFAULT_LOAD_FACTOR ) + 1, 16 ),
+ DEFAULT_LOAD_FACTOR );
+ putAll( t );
+ }
+
+ // internal utilities
+
+ /**
+ * Value representing null keys inside tables.
+ */
+ private static final Object NULL_KEY = new Object();
+
+ /**
+ * Use NULL_KEY for key if it is null.
+ */
+ private static Object maskNull(Object key) {
+ return ( key == null ?
+ NULL_KEY :
+ key );
+ }
+
+ /**
+ * Return internal representation of null key back to caller as null
+ */
+ private static Object unmaskNull(Object key) {
+ return ( key == NULL_KEY ?
+ null :
+ key );
+ }
+
+ /**
+ * Return a hash code for non-null Object x.
+ */
+ int hash(Object x) {
+ int h = System.identityHashCode( x );
+ return h - ( h << 7 ); // that is,, -127 * h
+ }
+
+ /**
+ * Return index for hash code h.
+ */
+ static int indexFor(int h, int length) {
+ return h & ( length - 1 );
+ }
+
+ /**
+ * Expunge stale entries from the table.
+ */
+ private void expungeStaleEntries() {
+ Object r;
+ while ( ( r = queue.poll() ) != null ) {
+ Entry e = (Entry) r;
+ int h = e.hash;
+ int i = indexFor( h, table.length );
+
+ Entry prev = table[i];
+ Entry p = prev;
+ while ( p != null ) {
+ Entry next = p.next;
+ if ( p == e ) {
+ if ( prev == e )
+ table[i] = next;
+ else
+ prev.next = next;
+ e.next = null; // Help GC
+ e.value = null; // " "
+ size--;
+ break;
+ }
+ prev = p;
+ p = next;
+ }
+ }
+ }
+
+ /**
+ * Return the table after first expunging stale entries
+ */
+ private Entry[] getTable() {
+ expungeStaleEntries();
+ return table;
+ }
+
+ /**
+ * Returns the number of key-value mappings in this map.
+ * This result is a snapshot, and may not reflect unprocessed
+ * entries that will be removed before next attempted access
+ * because they are no longer referenced.
+ */
+ public int size() {
+ if ( size == 0 )
+ return 0;
+ expungeStaleEntries();
+ return size;
+ }
+
+ /**
+ * Returns <tt>true</tt> if this map contains no key-value mappings.
+ * This result is a snapshot, and may not reflect unprocessed
+ * entries that will be removed before next attempted access
+ * because they are no longer referenced.
+ */
+ public boolean isEmpty() {
+ return size() == 0;
+ }
+
+ /**
+ * Returns the value to which the specified key is mapped in this weak
+ * hash map, or <tt>null</tt> if the map contains no mapping for
+ * this key. A return value of <tt>null</tt> does not <i>necessarily</i>
+ * indicate that the map contains no mapping for the key; it is also
+ * possible that the map explicitly maps the key to <tt>null</tt>. The
+ * <tt>containsKey</tt> method may be used to distinguish these two
+ * cases.
+ *
+ * @param key the key whose associated value is to be returned.
+ * @return the value to which this map maps the specified key, or
+ * <tt>null</tt> if the map contains no mapping for this key.
+ * @see #put(Object,Object)
+ */
+ public Object get(Object key) {
+ Object k = maskNull( key );
+ int h = hash( k );
+ Entry[] tab = getTable();
+ int index = indexFor( h, tab.length );
+ Entry e = tab[index];
+ while ( e != null ) {
+ if ( e.hash == h && k == e.get() )
+ return e.value;
+ e = e.next;
+ }
+ return null;
+ }
+
+ /**
+ * Returns <tt>true</tt> if this map contains a mapping for the
+ * specified key.
+ *
+ * @param key The key whose presence in this map is to be tested
+ * @return <tt>true</tt> if there is a mapping for <tt>key</tt>;
+ * <tt>false</tt> otherwise
+ */
+ public boolean containsKey(Object key) {
+ return getEntry( key ) != null;
+ }
+
+ /**
+ * Returns the entry associated with the specified key in the HashMap.
+ * Returns null if the HashMap contains no mapping for this key.
+ */
+ Entry getEntry(Object key) {
+ Object k = maskNull( key );
+ int h = hash( k );
+ Entry[] tab = getTable();
+ int index = indexFor( h, tab.length );
+ Entry e = tab[index];
+ while ( e != null && !( e.hash == h && k == e.get() ) )
+ e = e.next;
+ return e;
+ }
+
+ /**
+ * Associates the specified value with the specified key in this map.
+ * If the map previously contained a mapping for this key, the old
+ * value is replaced.
+ *
+ * @param key key with which the specified value is to be associated.
+ * @param value value to be associated with the specified key.
+ * @return previous value associated with specified key, or <tt>null</tt>
+ * if there was no mapping for key. A <tt>null</tt> return can
+ * also indicate that the HashMap previously associated
+ * <tt>null</tt> with the specified key.
+ */
+ public Object put(Object key, Object value) {
+ Object k = maskNull( key );
+ int h = hash( k );
+ Entry[] tab = getTable();
+ int i = indexFor( h, tab.length );
+
+ for ( Entry e = tab[i]; e != null; e = e.next ) {
+ if ( h == e.hash && k == e.get() ) {
+ Object oldValue = e.value;
+ if ( value != oldValue )
+ e.value = value;
+ return oldValue;
+ }
+ }
+
+ modCount++;
+ tab[i] = new Entry( k, value, queue, h, tab[i] );
+ if ( ++size >= threshold )
+ resize( tab.length * 2 );
+ return null;
+ }
+
+ /**
+ * Rehashes the contents of this map into a new <tt>HashMap</tt> instance
+ * with a larger capacity. This method is called automatically when the
+ * number of keys in this map exceeds its capacity and load factor.
+ * <p/>
+ * Note that this method is a no-op if it's called with newCapacity ==
+ * 2*MAXIMUM_CAPACITY (which is Integer.MIN_VALUE).
+ *
+ * @param newCapacity the new capacity, MUST be a power of two.
+ */
+ void resize(int newCapacity) {
+ // assert (newCapacity & -newCapacity) == newCapacity; // power of 2
+
+ Entry[] oldTable = getTable();
+ int oldCapacity = oldTable.length;
+
+ // check if needed
+ if ( size < threshold || oldCapacity > newCapacity )
+ return;
+
+ Entry[] newTable = new Entry[newCapacity];
+
+ transfer( oldTable, newTable );
+ table = newTable;
+
+ /*
+ * If ignoring null elements and processing ref queue caused massive
+ * shrinkage, then restore old table. This should be rare, but avoids
+ * unbounded expansion of garbage-filled tables.
+ */
+ if ( size >= threshold / 2 ) {
+ threshold = (int) ( newCapacity * loadFactor );
+ }
+ else {
+ expungeStaleEntries();
+ transfer( newTable, oldTable );
+ table = oldTable;
+ }
+ }
+
+ /**
+ * Transfer all entries from src to dest tables
+ */
+ private void transfer(Entry[] src, Entry[] dest) {
+ for ( int j = 0; j < src.length; ++j ) {
+ Entry e = src[j];
+ src[j] = null;
+ while ( e != null ) {
+ Entry next = e.next;
+ Object key = e.get();
+ if ( key == null ) {
+ e.next = null; // Help GC
+ e.value = null; // " "
+ size--;
+ }
+ else {
+ int i = indexFor( e.hash, dest.length );
+ e.next = dest[i];
+ dest[i] = e;
+ }
+ e = next;
+ }
+ }
+ }
+
+ /**
+ * Copies all of the mappings from the specified map to this map These
+ * mappings will replace any mappings that this map had for any of the
+ * keys currently in the specified map.<p>
+ *
+ * @param t mappings to be stored in this map.
+ * @throws NullPointerException if the specified map is null.
+ */
+ public void putAll(Map t) {
+ // Expand enough to hold t's elements without resizing.
+ int n = t.size();
+ if ( n == 0 )
+ return;
+ if ( n >= threshold ) {
+ n = (int) ( n / loadFactor + 1 );
+ if ( n > MAXIMUM_CAPACITY )
+ n = MAXIMUM_CAPACITY;
+ int capacity = table.length;
+ while ( capacity < n )
+ capacity <<= 1;
+ resize( capacity );
+ }
+
+ for ( Iterator i = t.entrySet().iterator(); i.hasNext(); ) {
+ Map.Entry e = (Map.Entry) i.next();
+ put( e.getKey(), e.getValue() );
+ }
+ }
+
+ /**
+ * Removes the mapping for this key from this map if present.
+ *
+ * @param key key whose mapping is to be removed from the map.
+ * @return previous value associated with specified key, or <tt>null</tt>
+ * if there was no mapping for key. A <tt>null</tt> return can
+ * also indicate that the map previously associated <tt>null</tt>
+ * with the specified key.
+ */
+ public Object remove(Object key) {
+ Object k = maskNull( key );
+ int h = hash( k );
+ Entry[] tab = getTable();
+ int i = indexFor( h, tab.length );
+ Entry prev = tab[i];
+ Entry e = prev;
+
+ while ( e != null ) {
+ Entry next = e.next;
+ if ( h == e.hash && k == e.get() ) {
+ modCount++;
+ size--;
+ if ( prev == e )
+ tab[i] = next;
+ else
+ prev.next = next;
+ return e.value;
+ }
+ prev = e;
+ e = next;
+ }
+
+ return null;
+ }
+
+
+ /**
+ * Special version of remove needed by Entry set
+ */
+ Entry removeMapping(Object o) {
+ if ( !( o instanceof Map.Entry ) )
+ return null;
+ Entry[] tab = getTable();
+ Map.Entry entry = (Map.Entry) o;
+ Object k = maskNull( entry.getKey() );
+ int h = hash( k );
+ int i = indexFor( h, tab.length );
+ Entry prev = tab[i];
+ Entry e = prev;
+
+ while ( e != null ) {
+ Entry next = e.next;
+ if ( h == e.hash && e.equals( entry ) ) {
+ modCount++;
+ size--;
+ if ( prev == e )
+ tab[i] = next;
+ else
+ prev.next = next;
+ return e;
+ }
+ prev = e;
+ e = next;
+ }
+
+ return null;
+ }
+
+ /**
+ * Removes all mappings from this map.
+ */
+ public void clear() {
+ // clear out ref queue. We don't need to expunge entries
+ // since table is getting cleared.
+ while ( queue.poll() != null )
+ ;
+
+ modCount++;
+ Entry tab[] = table;
+ for ( int i = 0; i < tab.length; ++i )
+ tab[i] = null;
+ size = 0;
+
+ // Allocation of array may have caused GC, which may have caused
+ // additional entries to go stale. Removing these entries from the
+ // reference queue will make them eligible for reclamation.
+ while ( queue.poll() != null )
+ ;
+ }
+
+ /**
+ * Returns <tt>true</tt> if this map maps one or more keys to the
+ * specified value.
+ *
+ * @param value value whose presence in this map is to be tested.
+ * @return <tt>true</tt> if this map maps one or more keys to the
+ * specified value.
+ */
+ public boolean containsValue(Object value) {
+ if ( value == null )
+ return containsNullValue();
+
+ Entry tab[] = getTable();
+ for ( int i = tab.length; i-- > 0; )
+ for ( Entry e = tab[i]; e != null; e = e.next )
+ if ( value.equals( e.value ) )
+ return true;
+ return false;
+ }
+
+ /**
+ * Special-case code for containsValue with null argument
+ */
+ private boolean containsNullValue() {
+ Entry tab[] = getTable();
+ for ( int i = tab.length; i-- > 0; )
+ for ( Entry e = tab[i]; e != null; e = e.next )
+ if ( e.value == null )
+ return true;
+ return false;
+ }
+
+ /**
+ * Remove elements having the according value.
+ * Intended to avoid concurrent access exceptions
+ * It is expected that nobody add a key being removed by value
+ *
+ * @param value value whose presence in this map is to be removed.
+ * @return <tt>true</tt> if this map maps one or more keys to the
+ * specified value.
+ */
+ public boolean removeValue(Object value) {
+ if ( value == null )
+ return removeNullValue();
+
+ Entry tab[] = getTable();
+ Set keys = new HashSet();
+ for ( int i = tab.length; i-- > 0; )
+ for ( Entry e = tab[i]; e != null; e = e.next )
+ if ( value.equals( e.value ) )
+ keys.add( e.getKey() );
+ for ( Object key : keys ) remove( key );
+ return !keys.isEmpty();
+ }
+
+ /**
+ * Special-case code for removeValue with null argument
+ */
+ private boolean removeNullValue() {
+ Entry tab[] = getTable();
+ Set keys = new HashSet();
+ for ( int i = tab.length; i-- > 0; )
+ for ( Entry e = tab[i]; e != null; e = e.next )
+ if ( e.value == null )
+ keys.add( e.getKey() );
+ for ( Object key : keys ) remove( key );
+ return !keys.isEmpty();
+ }
+
+ /**
+ * The entries in this hash table extend WeakReference, using its main ref
+ * field as the key.
+ */
+ private static class Entry extends WeakReference implements Map.Entry {
+ private Object value;
+ private final int hash;
+ private Entry next;
+
+ /**
+ * Create new entry.
+ */
+ Entry(Object key, Object value, ReferenceQueue queue,
+ int hash, Entry next) {
+ super( key, queue );
+ this.value = value;
+ this.hash = hash;
+ this.next = next;
+ }
+
+ public Object getKey() {
+ return unmaskNull( this.get() );
+ }
+
+ public Object getValue() {
+ return value;
+ }
+
+ public Object setValue(Object newValue) {
+ Object oldValue = value;
+ value = newValue;
+ return oldValue;
+ }
+
+ public boolean equals(Object o) {
+ if ( !( o instanceof Map.Entry ) )
+ return false;
+ Map.Entry e = (Map.Entry) o;
+ Object k1 = getKey();
+ Object k2 = e.getKey();
+ if ( k1 == k2 ) {
+ Object v1 = getValue();
+ Object v2 = e.getValue();
+ if ( v1 == v2 || ( v1 != null && v1.equals( v2 ) ) )
+ return true;
+ }
+ return false;
+ }
+
+ public int hashCode() {
+ Object k = getKey();
+ Object v = getValue();
+ return ( ( k == null ?
+ 0 :
+ System.identityHashCode( k ) ) ^
+ ( v == null ?
+ 0 :
+ v.hashCode() ) );
+ }
+
+ public String toString() {
+ return getKey() + "=" + getValue();
+ }
+ }
+
+ private abstract class HashIterator implements Iterator {
+ int index;
+ Entry entry = null;
+ Entry lastReturned = null;
+ int expectedModCount = modCount;
+
+ /**
+ * Strong reference needed to avoid disappearance of key
+ * between hasNext and next
+ */
+ Object nextKey = null;
+
+ /**
+ * Strong reference needed to avoid disappearance of key
+ * between nextEntry() and any use of the entry
+ */
+ Object currentKey = null;
+
+ HashIterator() {
+ index = ( size() != 0 ?
+ table.length :
+ 0 );
+ }
+
+ public boolean hasNext() {
+ Entry[] t = table;
+
+ while ( nextKey == null ) {
+ Entry e = entry;
+ int i = index;
+ while ( e == null && i > 0 )
+ e = t[--i];
+ entry = e;
+ index = i;
+ if ( e == null ) {
+ currentKey = null;
+ return false;
+ }
+ nextKey = e.get(); // hold on to key in strong ref
+ if ( nextKey == null )
+ entry = entry.next;
+ }
+ return true;
+ }
+
+ /**
+ * The common parts of next() across different types of iterators
+ */
+ protected Entry nextEntry() {
+ if ( modCount != expectedModCount )
+ throw new ConcurrentModificationException();
+ if ( nextKey == null && !hasNext() )
+ throw new NoSuchElementException();
+
+ lastReturned = entry;
+ entry = entry.next;
+ currentKey = nextKey;
+ nextKey = null;
+ return lastReturned;
+ }
+
+ public void remove() {
+ if ( lastReturned == null )
+ throw new IllegalStateException();
+ if ( modCount != expectedModCount )
+ throw new ConcurrentModificationException();
+
+ WeakIdentityHashMap.this.remove( currentKey );
+ expectedModCount = modCount;
+ lastReturned = null;
+ currentKey = null;
+ }
+
+ }
+
+ private class ValueIterator extends HashIterator {
+ public Object next() {
+ return nextEntry().value;
+ }
+ }
+
+ private class KeyIterator extends HashIterator {
+ public Object next() {
+ return nextEntry().getKey();
+ }
+ }
+
+ private class EntryIterator extends HashIterator {
+ public Object next() {
+ return nextEntry();
+ }
+ }
+
+ // Views
+
+ private transient Set entrySet = null;
+
+ /**
+ * Returns a set view of the keys contained in this map. The set is
+ * backed by the map, so changes to the map are reflected in the set, and
+ * vice-versa. The set supports element removal, which removes the
+ * corresponding mapping from this map, via the <tt>Iterator.remove</tt>,
+ * <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt>, and
+ * <tt>clear</tt> operations. It does not support the <tt>add</tt> or
+ * <tt>addAll</tt> operations.
+ *
+ * @return a set view of the keys contained in this map.
+ */
+ public Set keySet() {
+ Set ks = keySet;
+ return ( ks != null ?
+ ks :
+ ( keySet = new KeySet() ) );
+ }
+
+ private class KeySet extends AbstractSet {
+ public Iterator iterator() {
+ return new KeyIterator();
+ }
+
+ public int size() {
+ return WeakIdentityHashMap.this.size();
+ }
+
+ public boolean contains(Object o) {
+ return containsKey( o );
+ }
+
+ public boolean remove(Object o) {
+ if ( containsKey( o ) ) {
+ WeakIdentityHashMap.this.remove( o );
+ return true;
+ }
+ else
+ return false;
+ }
+
+ public void clear() {
+ WeakIdentityHashMap.this.clear();
+ }
+
+ public Object[] toArray() {
+ Collection c = new ArrayList( size() );
+ for ( Iterator i = iterator(); i.hasNext(); )
+ c.add( i.next() );
+ return c.toArray();
+ }
+
+ public Object[] toArray(Object a[]) {
+ Collection c = new ArrayList( size() );
+ for ( Iterator i = iterator(); i.hasNext(); )
+ c.add( i.next() );
+ return c.toArray( a );
+ }
+ }
+
+ /**
+ * Returns a collection view of the values contained in this map. The
+ * collection is backed by the map, so changes to the map are reflected in
+ * the collection, and vice-versa. The collection supports element
+ * removal, which removes the corresponding mapping from this map, via the
+ * <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>,
+ * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> operations.
+ * It does not support the <tt>add</tt> or <tt>addAll</tt> operations.
+ *
+ * @return a collection view of the values contained in this map.
+ */
+ public Collection values() {
+ Collection vs = values;
+ return ( vs != null ?
+ vs :
+ ( values = new Values() ) );
+ }
+
+ private class Values extends AbstractCollection {
+ public Iterator iterator() {
+ return new ValueIterator();
+ }
+
+ public int size() {
+ return WeakIdentityHashMap.this.size();
+ }
+
+ public boolean contains(Object o) {
+ return containsValue( o );
+ }
+
+ public void clear() {
+ WeakIdentityHashMap.this.clear();
+ }
+
+ public Object[] toArray() {
+ Collection c = new ArrayList( size() );
+ for ( Iterator i = iterator(); i.hasNext(); )
+ c.add( i.next() );
+ return c.toArray();
+ }
+
+ public Object[] toArray(Object a[]) {
+ Collection c = new ArrayList( size() );
+ for ( Iterator i = iterator(); i.hasNext(); )
+ c.add( i.next() );
+ return c.toArray( a );
+ }
+ }
+
+ /**
+ * Returns a collection view of the mappings contained in this map. Each
+ * element in the returned collection is a <tt>Map.Entry</tt>. The
+ * collection is backed by the map, so changes to the map are reflected in
+ * the collection, and vice-versa. The collection supports element
+ * removal, which removes the corresponding mapping from the map, via the
+ * <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>,
+ * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> operations.
+ * It does not support the <tt>add</tt> or <tt>addAll</tt> operations.
+ *
+ * @return a collection view of the mappings contained in this map.
+ * @see java.util.Map.Entry
+ */
+ public Set entrySet() {
+ Set es = entrySet;
+ return ( es != null ?
+ es :
+ ( entrySet = new EntrySet() ) );
+ }
+
+ private class EntrySet extends AbstractSet {
+ public Iterator iterator() {
+ return new EntryIterator();
+ }
+
+ public boolean contains(Object o) {
+ if ( !( o instanceof Map.Entry ) )
+ return false;
+ Map.Entry e = (Map.Entry) o;
+ Object k = e.getKey();
+ Entry candidate = getEntry( e.getKey() );
+ return candidate != null && candidate.equals( e );
+ }
+
+ public boolean remove(Object o) {
+ return removeMapping( o ) != null;
+ }
+
+ public int size() {
+ return WeakIdentityHashMap.this.size();
+ }
+
+ public void clear() {
+ WeakIdentityHashMap.this.clear();
+ }
+
+ public Object[] toArray() {
+ Collection c = new ArrayList( size() );
+ for ( Iterator i = iterator(); i.hasNext(); )
+ c.add( new SimpleEntry( (Map.Entry) i.next() ) );
+ return c.toArray();
+ }
+
+ public Object[] toArray(Object a[]) {
+ Collection c = new ArrayList( size() );
+ for ( Iterator i = iterator(); i.hasNext(); )
+ c.add( new SimpleEntry( (Map.Entry) i.next() ) );
+ return c.toArray( a );
+ }
+ }
+
+ static class SimpleEntry implements Map.Entry {
+ Object key;
+ Object value;
+
+ public SimpleEntry(Object key, Object value) {
+ this.key = key;
+ this.value = value;
+ }
+
+ public SimpleEntry(Map.Entry e) {
+ this.key = e.getKey();
+ this.value = e.getValue();
+ }
+
+ public Object getKey() {
+ return key;
+ }
+
+ public Object getValue() {
+ return value;
+ }
+
+ public Object setValue(Object value) {
+ Object oldValue = this.value;
+ this.value = value;
+ return oldValue;
+ }
+
+ public boolean equals(Object o) {
+ if ( !( o instanceof Map.Entry ) )
+ return false;
+ Map.Entry e = (Map.Entry) o;
+ return eq( key, e.getKey() ) && eq( value, e.getValue() );
+ }
+
+ public int hashCode() {
+ Object v;
+ return ( ( key == null ) ?
+ 0 :
+ key.hashCode() ) ^
+ ( ( value == null ) ?
+ 0 :
+ value.hashCode() );
+ }
+
+ public String toString() {
+ return key + "=" + value;
+ }
+
+ private static boolean eq(Object o1, Object o2) {
+ return ( o1 == null ?
+ o2 == null :
+ o1.equals( o2 ) );
+ }
+ }
+
+}
Modified: branches/Branch_3_2/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java
===================================================================
--- branches/Branch_3_2/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java 2006-11-25 14:23:04 UTC (rev 10869)
+++ branches/Branch_3_2/HibernateExt/metadata/src/test/org/hibernate/search/test/TransactionTest.java 2006-11-26 14:16:21 UTC (rev 10870)
@@ -17,10 +17,16 @@
s.persist(
new Document( "Hibernate in Action", "Object/relational mapping with Hibernate", "blah blah blah" )
);
+ s.persist(
+ new Document( "Lucene in Action", "FullText search engine", "blah blah blah" )
+ );
+ s.persist(
+ new Document( "Hibernate Search in Action", "ORM and FullText search engine", "blah blah blah" )
+ );
s.getTransaction().commit();
s.close();
- assertEquals( "transaction.commit() should no index", 1, getDocumentNumber() );
+ assertEquals( "transaction.commit() should index", 3, getDocumentNumber() );
s = getSessions().openSession();
s.getTransaction().begin();
@@ -31,7 +37,7 @@
s.getTransaction().rollback();
s.close();
- assertEquals( "rollback() should not index", 1, getDocumentNumber() );
+ assertEquals( "rollback() should not index", 3, getDocumentNumber() );
s = getSessions().openSession();
s.persist(
@@ -40,7 +46,7 @@
s.flush();
s.close();
- assertEquals( "no transaction should index", 2, getDocumentNumber() );
+ assertEquals( "no transaction should index", 4, getDocumentNumber() );
}
More information about the hibernate-commits
mailing list