Author: steve.ebersole(a)jboss.com Date: 2007-01-23 08:54:33 -0500 (Tue, 23 Jan 2007) New Revision: 11078 Modified: trunk/Hibernate3/src/org/hibernate/engine/StatefulPersistenceContext.java Log: HHH-2112 : persistence-context cached db snapshot; javadocs Modified: trunk/Hibernate3/src/org/hibernate/engine/StatefulPersistenceContext.java =================================================================== --- trunk/Hibernate3/src/org/hibernate/engine/StatefulPersistenceContext.java 2007-01-23 12:54:42 UTC (rev 11077) +++ trunk/Hibernate3/src/org/hibernate/engine/StatefulPersistenceContext.java 2007-01-23 13:54:33 UTC (rev 11078) @@ -24,6 +24,7 @@ import org.hibernate.NonUniqueObjectException; import org.hibernate.PersistentObjectException; import org.hibernate.TransientObjectException; +import org.hibernate.pretty.MessageHelper; import org.hibernate.collection.PersistentCollection; import org.hibernate.persister.collection.CollectionPersister; import org.hibernate.persister.entity.EntityPersister; @@ -272,9 +273,23 @@ } } + /** + * Retrieve the cached database snapshot for the requested entity key. + * <p/> + * This differs from {@link #getDatabaseSnapshot} is two important respects:<ol> + * <li>no snapshot is obtained from the database if not already cached</li> + * <li>an entry of {@link #NO_ROW} here is interpretet as an exception</li> + * </ol> + * @param key The entity key for which to retrieve the cached snapshot + * @return The cached snapshot + * @throws IllegalStateException if the cached snapshot was == {@link #NO_ROW}. + */ public Object[] getCachedDatabaseSnapshot(EntityKey key) { - //TODO: assertion failure if NO_ROW - return (Object[]) entitySnapshotsByKey.get(key); + Object snapshot = entitySnapshotsByKey.get( key ); + if ( snapshot == NO_ROW ) { + throw new IllegalStateException( "persistence context reported no row snapshot for " + MessageHelper.infoString( key.getEntityName(), key.getIdentifier() ) ); + } + return ( Object[] ) snapshot; } /*public void removeDatabaseSnapshot(EntityKey key) { @@ -482,13 +497,19 @@ /** * Associate a proxy that was instantiated by another session with this session + * + * @param li The proxy initializer. + * @param proxy The proxy to reassociate. */ - private void reassociateProxy(LazyInitializer li, HibernateProxy proxy) throws HibernateException { - if ( li.getSession() != this ) { + private void reassociateProxy(LazyInitializer li, HibernateProxy proxy) { + if ( li.getSession() != this.getSession() ) { EntityPersister persister = session.getFactory().getEntityPersister( li.getEntityName() ); EntityKey key = new EntityKey( li.getIdentifier(), persister, session.getEntityMode() ); - if ( !proxiesByKey.containsKey(key) ) proxiesByKey.put(key, proxy); // any earlier proxy takes precedence - proxy.getHibernateLazyInitializer().setSession(session); + // any earlier proxy takes precedence + if ( !proxiesByKey.containsKey( key ) ) { + proxiesByKey.put( key, proxy ); + } + proxy.getHibernateLazyInitializer().setSession( session ); } } @@ -669,19 +690,25 @@ throws HibernateException { addCollection(collection, persister); } - + /** - * Add an collection to the cache, with a given collection entry + * Add an collection to the cache, with a given collection entry. + * + * @param coll The collection for which we are adding an entry. + * @param entry The entry representing the collection. + * @param key The key of the collection's entry. */ private void addCollection(PersistentCollection coll, CollectionEntry entry, Serializable key) { - collectionEntries.put(coll, entry); + collectionEntries.put( coll, entry ); CollectionKey collectionKey = new CollectionKey( entry.getLoadedPersister(), key, session.getEntityMode() ); - PersistentCollection old = (PersistentCollection) collectionsByKey.put(collectionKey, coll); + PersistentCollection old = ( PersistentCollection ) collectionsByKey.put( collectionKey, coll ); if ( old != null ) { - if (old==coll) throw new AssertionFailure("bug adding collection twice"); + if ( old == coll ) { + throw new AssertionFailure("bug adding collection twice"); + } // or should it actually throw an exception? - old.unsetSession(session); - collectionEntries.remove(old); + old.unsetSession( session ); + collectionEntries.remove( old ); // watch out for a case where old is still referenced // somewhere in the object graph! (which is a user error) } @@ -689,11 +716,13 @@ /** * Add a collection to the cache, creating a new collection entry for it + * + * @param collection The collection for which we are adding an entry. + * @param persister The collection persister */ - private void addCollection(PersistentCollection collection, CollectionPersister persister) - throws HibernateException { - CollectionEntry ce = new CollectionEntry(persister, collection); - collectionEntries.put(collection, ce); + private void addCollection(PersistentCollection collection, CollectionPersister persister) { + CollectionEntry ce = new CollectionEntry( persister, collection ); + collectionEntries.put( collection, ce ); } /** @@ -1134,7 +1163,7 @@ * persistence context. * * @param oos The stream to which the persistence context should get written - * @throws IOException + * @throws IOException serialization errors. */ public void serialize(ObjectOutputStream oos) throws IOException { log.trace( "serializing persistent-context" );