| Methods Summary |
|---|
| private void | addCollection(org.hibernate.collection.PersistentCollection coll, CollectionEntry entry, java.io.Serializable key)Add an collection to the cache, with a given collection entry.
collectionEntries.put( coll, entry );
CollectionKey collectionKey = new CollectionKey( entry.getLoadedPersister(), key, session.getEntityMode() );
PersistentCollection old = ( PersistentCollection ) collectionsByKey.put( collectionKey, coll );
if ( old != null ) {
if ( old == coll ) {
throw new AssertionFailure("bug adding collection twice");
}
// or should it actually throw an exception?
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)
}
|
| private void | addCollection(org.hibernate.collection.PersistentCollection collection, org.hibernate.persister.collection.CollectionPersister persister)Add a collection to the cache, creating a new collection entry for it
CollectionEntry ce = new CollectionEntry( persister, collection );
collectionEntries.put( collection, ce );
|
| public void | addCollectionHolder(org.hibernate.collection.PersistentCollection holder)Register a PersistentCollection object for an array.
Associates a holder with an array - MUST be called after loading
array, since the array instance is not created until endLoad().
//TODO:refactor + make this method private
arrayHolders.put( holder.getValue(), holder );
|
| public void | addEntity(EntityKey key, java.lang.Object entity)
entitiesByKey.put(key, entity);
getBatchFetchQueue().removeBatchLoadableEntityKey(key);
|
| public void | addEntity(EntityUniqueKey euk, java.lang.Object entity)Add an entity to the cache by unique key
entitiesByUniqueKey.put(euk, entity);
|
| public EntityEntry | addEntity(java.lang.Object entity, Status status, java.lang.Object[] loadedState, EntityKey entityKey, java.lang.Object version, org.hibernate.LockMode lockMode, boolean existsInDatabase, org.hibernate.persister.entity.EntityPersister persister, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched)Adds an entity to the internal caches.
addEntity( entityKey, entity );
return addEntry(
entity,
status,
loadedState,
null,
entityKey.getIdentifier(),
version,
lockMode,
existsInDatabase,
persister,
disableVersionIncrement,
lazyPropertiesAreUnfetched
);
|
| public EntityEntry | addEntry(java.lang.Object entity, Status status, java.lang.Object[] loadedState, java.lang.Object rowId, java.io.Serializable id, java.lang.Object version, org.hibernate.LockMode lockMode, boolean existsInDatabase, org.hibernate.persister.entity.EntityPersister persister, boolean disableVersionIncrement, boolean lazyPropertiesAreUnfetched)Generates an appropriate EntityEntry instance and adds it
to the event source's internal caches.
EntityEntry e = new EntityEntry(
status,
loadedState,
rowId,
id,
version,
lockMode,
existsInDatabase,
persister,
session.getEntityMode(),
disableVersionIncrement,
lazyPropertiesAreUnfetched
);
entityEntries.put(entity, e);
setHasNonReadOnlyEnties(status);
return e;
|
| public CollectionEntry | addInitializedCollection(org.hibernate.persister.collection.CollectionPersister persister, org.hibernate.collection.PersistentCollection collection, java.io.Serializable id)add a collection we just pulled out of the cache (does not need initializing)
CollectionEntry ce = new CollectionEntry(collection, persister, id, flushing);
ce.postInitialize(collection);
addCollection(collection, ce, id);
return ce;
|
| public void | addInitializedDetachedCollection(org.hibernate.persister.collection.CollectionPersister collectionPersister, org.hibernate.collection.PersistentCollection collection)add an (initialized) collection that was created by another session and passed
into update() (ie. one with a snapshot and existing state on the database)
if ( collection.isUnreferenced() ) {
//treat it just like a new collection
addCollection( collection, collectionPersister );
}
else {
CollectionEntry ce = new CollectionEntry( collection, session.getFactory() );
addCollection( collection, ce, collection.getKey() );
}
|
| public void | addNewCollection(org.hibernate.persister.collection.CollectionPersister persister, org.hibernate.collection.PersistentCollection collection)Add a new collection (ie. a newly created one, just instantiated by the
application, with no database state or snapshot)
addCollection(collection, persister);
|
| public void | addNonLazyCollection(org.hibernate.collection.PersistentCollection collection)Register a collection for non-lazy loading at the end of the
two-phase load
nonlazyCollections.add(collection);
|
| public void | addNullProperty(EntityKey ownerKey, java.lang.String propertyName)Record the fact that the association belonging to the keyed
entity is null.
nullAssociations.add( new AssociationKey(ownerKey, propertyName) );
|
| public void | addProxy(EntityKey key, java.lang.Object proxy)Add a proxy to the session cache
proxiesByKey.put(key, proxy);
|
| public void | addUninitializedCollection(org.hibernate.persister.collection.CollectionPersister persister, org.hibernate.collection.PersistentCollection collection, java.io.Serializable id)add a collection we just loaded up (still needs initializing)
CollectionEntry ce = new CollectionEntry(collection, persister, id, flushing);
addCollection(collection, ce, id);
|
| public void | addUninitializedDetachedCollection(org.hibernate.persister.collection.CollectionPersister persister, org.hibernate.collection.PersistentCollection collection)add a detached uninitialized collection
CollectionEntry ce = new CollectionEntry( persister, collection.getKey() );
addCollection( collection, ce, collection.getKey() );
|
| public void | addUnownedCollection(CollectionKey key, org.hibernate.collection.PersistentCollection collection)
if (unownedCollections==null) {
unownedCollections = new HashMap(8);
}
unownedCollections.put(key, collection);
|
| public void | afterLoad()Call this after finishing a two-phase load
loadCounter--;
|
| public void | afterTransactionCompletion()
// Downgrade locks
Iterator iter = entityEntries.values().iterator();
while ( iter.hasNext() ) {
( (EntityEntry) iter.next() ).setLockMode(LockMode.NONE);
}
|
| public void | beforeLoad()Call this before begining a two-phase load
loadCounter++;
|
| public void | checkUniqueness(EntityKey key, java.lang.Object object)Attempts to check whether the given key represents an entity already loaded within the
current session.
Object entity = getEntity(key);
if ( entity == object ) {
throw new AssertionFailure( "object already associated, but no entry was found" );
}
if ( entity != null ) {
throw new NonUniqueObjectException( key.getIdentifier(), key.getEntityName() );
}
|
| public void | clear()
Iterator itr = proxiesByKey.values().iterator();
while ( itr.hasNext() ) {
final LazyInitializer li = ( ( HibernateProxy ) itr.next() ).getHibernateLazyInitializer();
li.setSession( null );
}
Map.Entry[] collectionEntryArray = IdentityMap.concurrentEntries( collectionEntries );
for ( int i = 0; i < collectionEntryArray.length; i++ ) {
( ( PersistentCollection ) collectionEntryArray[i].getKey() ).unsetSession( getSession() );
}
arrayHolders.clear();
entitiesByKey.clear();
entitiesByUniqueKey.clear();
entityEntries.clear();
entitySnapshotsByKey.clear();
collectionsByKey.clear();
collectionEntries.clear();
if ( unownedCollections != null ) {
unownedCollections.clear();
}
proxiesByKey.clear();
nullifiableEntityKeys.clear();
if ( batchFetchQueue != null ) {
batchFetchQueue.clear();
}
hasNonReadOnlyEntities = false;
if ( loadContexts != null ) {
loadContexts.cleanup();
}
|
| private void | clearNullProperties()
nullAssociations.clear();
|
| public boolean | containsCollection(org.hibernate.collection.PersistentCollection collection)
return collectionEntries.containsKey(collection);
|
| public boolean | containsEntity(EntityKey key)
return entitiesByKey.containsKey(key);
|
| public boolean | containsProxy(java.lang.Object entity)
return proxiesByKey.containsValue( entity );
|
| public int | decrementCascadeLevel()
return --cascading;
|
| public static org.hibernate.engine.StatefulPersistenceContext | deserialize(java.io.ObjectInputStream ois, SessionImplementor session)
log.trace( "deserializing persistent-context" );
StatefulPersistenceContext rtn = new StatefulPersistenceContext( session );
// during deserialization, we need to reconnect all proxies and
// collections to this session, as well as the EntityEntry and
// CollectionEntry instances; these associations are transient
// because serialization is used for different things.
try {
// todo : we can actually just determine this from the incoming EntityEntry-s
rtn.hasNonReadOnlyEntities = ois.readBoolean();
int count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] entitiesByKey entries" );
rtn.entitiesByKey = new HashMap( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
rtn.entitiesByKey.put( EntityKey.deserialize( ois, session ), ois.readObject() );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] entitiesByUniqueKey entries" );
rtn.entitiesByUniqueKey = new HashMap( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
rtn.entitiesByUniqueKey.put( EntityUniqueKey.deserialize( ois, session ), ois.readObject() );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] proxiesByKey entries" );
rtn.proxiesByKey = new ReferenceMap( ReferenceMap.HARD, ReferenceMap.WEAK, count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count, .75f );
for ( int i = 0; i < count; i++ ) {
EntityKey ek = EntityKey.deserialize( ois, session );
Object proxy = ois.readObject();
if ( proxy instanceof HibernateProxy ) {
( ( HibernateProxy ) proxy ).getHibernateLazyInitializer().setSession( session );
rtn.proxiesByKey.put( ek, proxy );
}
else {
log.trace( "encountered prunded proxy" );
}
// otherwise, the proxy was pruned during the serialization process
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] entitySnapshotsByKey entries" );
rtn.entitySnapshotsByKey = new HashMap( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
rtn.entitySnapshotsByKey.put( EntityKey.deserialize( ois, session ), ois.readObject() );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] entityEntries entries" );
rtn.entityEntries = IdentityMap.instantiateSequenced( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
Object entity = ois.readObject();
EntityEntry entry = EntityEntry.deserialize( ois, session );
rtn.entityEntries.put( entity, entry );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] collectionsByKey entries" );
rtn.collectionsByKey = new HashMap( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
rtn.collectionsByKey.put( CollectionKey.deserialize( ois, session ), ois.readObject() );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] collectionEntries entries" );
rtn.collectionEntries = IdentityMap.instantiateSequenced( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
final PersistentCollection pc = ( PersistentCollection ) ois.readObject();
final CollectionEntry ce = CollectionEntry.deserialize( ois, session );
pc.setCurrentSession( session );
rtn.collectionEntries.put( pc, ce );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] arrayHolders entries" );
rtn.arrayHolders = IdentityMap.instantiate( count < INIT_COLL_SIZE ? INIT_COLL_SIZE : count );
for ( int i = 0; i < count; i++ ) {
rtn.arrayHolders.put( ois.readObject(), ois.readObject() );
}
count = ois.readInt();
log.trace( "staring deserialization of [" + count + "] nullifiableEntityKeys entries" );
rtn.nullifiableEntityKeys = new HashSet();
for ( int i = 0; i < count; i++ ) {
rtn.nullifiableEntityKeys.add( EntityKey.deserialize( ois, session ) );
}
}
catch ( HibernateException he ) {
throw new InvalidObjectException( he.getMessage() );
}
return rtn;
|
| public BatchFetchQueue | getBatchFetchQueue()Get the BatchFetchQueue, instantiating one if
necessary.
if (batchFetchQueue==null) {
batchFetchQueue = new BatchFetchQueue(this);
}
return batchFetchQueue;
|
| public java.lang.Object[] | getCachedDatabaseSnapshot(EntityKey key)Retrieve the cached database snapshot for the requested entity key.
This differs from {@link #getDatabaseSnapshot} is two important respects:
- no snapshot is obtained from the database if not already cached
- an entry of {@link #NO_ROW} here is interpretet as an exception
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 int | getCascadeLevel()Do we already know that the entity does not exist in the
database?
return cascading;
|
| public org.hibernate.collection.PersistentCollection | getCollection(CollectionKey collectionKey)Get the collection instance associated with the CollectionKey
return (PersistentCollection) collectionsByKey.get(collectionKey);
|
| public java.util.Map | getCollectionEntries()
return collectionEntries;
|
| public CollectionEntry | getCollectionEntry(org.hibernate.collection.PersistentCollection coll)Get the collection entry for a persistent collection
return (CollectionEntry) collectionEntries.get(coll);
|
| public CollectionEntry | getCollectionEntryOrNull(java.lang.Object collection)Get the collection entry for a collection passed to filter,
which might be a collection wrapper, an array, or an unwrapped
collection. Return null if there is no entry.
PersistentCollection coll;
if ( collection instanceof PersistentCollection ) {
coll = (PersistentCollection) collection;
//if (collection==null) throw new TransientObjectException("Collection was not yet persistent");
}
else {
coll = getCollectionHolder(collection);
if ( coll == null ) {
//it might be an unwrapped collection reference!
//try to find a wrapper (slowish)
Iterator wrappers = IdentityMap.keyIterator(collectionEntries);
while ( wrappers.hasNext() ) {
PersistentCollection pc = (PersistentCollection) wrappers.next();
if ( pc.isWrapper(collection) ) {
coll = pc;
break;
}
}
}
}
return (coll == null) ? null : getCollectionEntry(coll);
|
| public org.hibernate.collection.PersistentCollection | getCollectionHolder(java.lang.Object array)Get the PersistentCollection object for an array
return (PersistentCollection) arrayHolders.get(array);
|
| public java.lang.Object | getCollectionOwner(java.io.Serializable key, org.hibernate.persister.collection.CollectionPersister collectionPersister)Get the entity that owns this persistent collection
return getEntity( new EntityKey( key, collectionPersister.getOwnerEntityPersister(), session.getEntityMode() ) );
|
| public java.util.Map | getCollectionsByKey()
return collectionsByKey;
|
| public java.lang.Object[] | getDatabaseSnapshot(java.io.Serializable id, org.hibernate.persister.entity.EntityPersister persister)Get the current state of the entity as known to the underlying
database, or null if there is no corresponding row
EntityKey key = new EntityKey( id, persister, session.getEntityMode() );
Object cached = entitySnapshotsByKey.get(key);
if (cached!=null) {
return cached==NO_ROW ? null : (Object[]) cached;
}
else {
Object[] snapshot = persister.getDatabaseSnapshot( id, session );
entitySnapshotsByKey.put( key, snapshot==null ? NO_ROW : snapshot );
return snapshot;
}
|
| public java.util.Map | getEntitiesByKey()
return entitiesByKey;
|
| public java.lang.Object | getEntity(EntityKey key)Get the entity instance associated with the given
EntityKey
return entitiesByKey.get(key);
|
| public java.lang.Object | getEntity(EntityUniqueKey euk)Get an entity cached by unique key
return entitiesByUniqueKey.get(euk);
|
| public java.util.Map | getEntityEntries()
return entityEntries;
|
| public EntityEntry | getEntry(java.lang.Object entity)Retreive the EntityEntry representation of the given entity.
return (EntityEntry) entityEntries.get(entity);
|
| public java.lang.Object | getIndexInOwner(java.lang.String entity, java.lang.String property, java.lang.Object childEntity, java.util.Map mergeMap)Search the persistence context for an index of the child object,
given a collection role
EntityPersister persister = session.getFactory()
.getEntityPersister(entity);
CollectionPersister cp = session.getFactory()
.getCollectionPersister(entity + '." + property);
Iterator entities = entityEntries.entrySet().iterator();
while ( entities.hasNext() ) {
Map.Entry me = (Map.Entry) entities.next();
EntityEntry ee = (EntityEntry) me.getValue();
if ( persister.isSubclassEntityName( ee.getEntityName() ) ) {
Object instance = me.getKey();
Object index = getIndexInParent(property, childEntity, persister, cp, instance);
if (index==null && mergeMap!=null) {
Object unmergedInstance = mergeMap.get(instance);
Object unmergedChild = mergeMap.get(childEntity);
if ( unmergedInstance!=null && unmergedChild!=null ) {
index = getIndexInParent(property, unmergedChild, persister, cp, unmergedInstance);
}
}
if (index!=null) return index;
}
}
return null;
|
| private java.lang.Object | getIndexInParent(java.lang.String property, java.lang.Object childEntity, org.hibernate.persister.entity.EntityPersister persister, org.hibernate.persister.collection.CollectionPersister collectionPersister, java.lang.Object potentialParent)
Object collection = persister.getPropertyValue( potentialParent, property, session.getEntityMode() );
if ( collection!=null && Hibernate.isInitialized(collection) ) {
return collectionPersister.getCollectionType().indexOf(collection, childEntity);
}
else {
return null;
}
|
| public org.hibernate.engine.loading.LoadContexts | getLoadContexts()
if ( loadContexts == null ) {
loadContexts = new LoadContexts( this );
}
return loadContexts;
|
| public java.lang.Object[] | getNaturalIdSnapshot(java.io.Serializable id, org.hibernate.persister.entity.EntityPersister persister)
if ( !persister.hasNaturalIdentifier() ) {
return null;
}
// if the natural-id is marked as non-mutable, it is not retrieved during a
// normal database-snapshot operation...
int[] props = persister.getNaturalIdentifierProperties();
boolean[] updateable = persister.getPropertyUpdateability();
boolean allNatualIdPropsAreUpdateable = true;
for ( int i = 0; i < props.length; i++ ) {
if ( !updateable[ props[i] ] ) {
allNatualIdPropsAreUpdateable = false;
break;
}
}
if ( allNatualIdPropsAreUpdateable ) {
// do this when all the properties are updateable since there is
// a certain likelihood that the information will already be
// snapshot-cached.
Object[] entitySnapshot = getDatabaseSnapshot( id, persister );
if ( entitySnapshot == NO_ROW ) {
return null;
}
Object[] naturalIdSnapshot = new Object[ props.length ];
for ( int i = 0; i < props.length; i++ ) {
naturalIdSnapshot[i] = entitySnapshot[ props[i] ];
}
return naturalIdSnapshot;
}
else {
return persister.getNaturalIdentifierSnapshot( id, session );
}
|
| public java.util.HashSet | getNullifiableEntityKeys()Retrieve the set of EntityKeys representing nullifiable references
return nullifiableEntityKeys;
|
| public java.io.Serializable | getOwnerId(java.lang.String entity, java.lang.String property, java.lang.Object childEntity, java.util.Map mergeMap)Search the persistence context for an owner for the child object,
given a collection role. If mergeMap is non-null, also
check the detached graph being merged for a parent.
EntityPersister persister = session.getFactory()
.getEntityPersister(entity);
final CollectionPersister collectionPersister = session.getFactory()
.getCollectionPersister(entity + '." + property);
Iterator entities = entityEntries.entrySet().iterator();
while ( entities.hasNext() ) {
Map.Entry me = (Map.Entry) entities.next();
EntityEntry ee = (EntityEntry) me.getValue();
if ( persister.isSubclassEntityName( ee.getEntityName() ) ) {
Object instance = me.getKey();
//check if the managed object is the parent
boolean found = isFoundInParent(
property,
childEntity,
persister,
collectionPersister,
instance
);
if (!found && mergeMap!=null) {
//check if the detached object being merged is the parent
Object unmergedInstance = mergeMap.get(instance);
Object unmergedChild = mergeMap.get(childEntity);
if ( unmergedInstance!=null && unmergedChild!=null ) {
found = isFoundInParent(
property,
unmergedChild,
persister,
collectionPersister,
unmergedInstance
);
}
}
if ( found ) {
return ee.getId();
}
}
}
return null;
|
| public java.lang.Object | getProxy(EntityKey key)Get an existing proxy by key
return proxiesByKey.get(key);
|
| public SessionImplementor | getSession()
return session;
|
| public java.io.Serializable | getSnapshot(org.hibernate.collection.PersistentCollection coll)Get the snapshot of the pre-flush collection state
return getCollectionEntry(coll).getSnapshot();
|
| public boolean | hasNonReadOnlyEntities()
return hasNonReadOnlyEntities;
|
| public int | incrementCascadeLevel()
return ++cascading;
|
| private void | initTransientState()
nullAssociations = new HashSet( INIT_COLL_SIZE );
nonlazyCollections = new ArrayList( INIT_COLL_SIZE );
|
| public void | initializeNonLazyCollections()Force initialization of all non-lazy collections encountered during
the current two-phase load (actually, this is a no-op, unless this
is the "outermost" load)
if ( loadCounter == 0 ) {
log.debug( "initializing non-lazy collections" );
//do this work only at the very highest level of the load
loadCounter++; //don't let this method be called recursively
try {
int size;
while ( ( size = nonlazyCollections.size() ) > 0 ) {
//note that each iteration of the loop may add new elements
( (PersistentCollection) nonlazyCollections.remove( size - 1 ) ).forceInitialization();
}
}
finally {
loadCounter--;
clearNullProperties();
}
}
|
| public boolean | isEntryFor(java.lang.Object entity)Is there an EntityEntry for this instance?
return entityEntries.containsKey(entity);
|
| public boolean | isFlushing()
return flushing;
|
| private boolean | isFoundInParent(java.lang.String property, java.lang.Object childEntity, org.hibernate.persister.entity.EntityPersister persister, org.hibernate.persister.collection.CollectionPersister collectionPersister, java.lang.Object potentialParent)
Object collection = persister.getPropertyValue(
potentialParent,
property,
session.getEntityMode()
);
return collection!=null && Hibernate.isInitialized(collection) &&
collectionPersister.getCollectionType()
.contains(collection, childEntity, session);
|
| public boolean | isPropertyNull(EntityKey ownerKey, java.lang.String propertyName)Is the association property belonging to the keyed entity null?
return nullAssociations.contains( new AssociationKey(ownerKey, propertyName) );
|
| public boolean | isStateless()
return false;
|
| public java.lang.Object | narrowProxy(java.lang.Object proxy, org.hibernate.persister.entity.EntityPersister persister, EntityKey key, java.lang.Object object)If the existing proxy is insufficiently "narrow" (derived), instantiate a new proxy
and overwrite the registration of the old one. This breaks == and occurs only for
"class" proxies rather than "interface" proxies. Also init the proxy to point to
the given target implementation if necessary.
boolean alreadyNarrow = persister.getConcreteProxyClass( session.getEntityMode() )
.isAssignableFrom( proxy.getClass() );
if ( !alreadyNarrow ) {
if ( PROXY_WARN_LOG.isWarnEnabled() ) {
PROXY_WARN_LOG.warn(
"Narrowing proxy to " +
persister.getConcreteProxyClass( session.getEntityMode() ) +
" - this operation breaks =="
);
}
if ( object != null ) {
proxiesByKey.remove(key);
return object; //return the proxied object
}
else {
proxy = persister.createProxy( key.getIdentifier(), session );
proxiesByKey.put(key, proxy); //overwrite old proxy
return proxy;
}
}
else {
if ( object != null ) {
LazyInitializer li = ( (HibernateProxy) proxy ).getHibernateLazyInitializer();
li.setImplementation(object);
}
return proxy;
}
|
| public java.lang.Object | proxyFor(org.hibernate.persister.entity.EntityPersister persister, EntityKey key, java.lang.Object impl)Return the existing proxy associated with the given EntityKey, or the
third argument (the entity associated with the key) if no proxy exists. Init
the proxy to the target implementation, if necessary.
if ( !persister.hasProxy() ) return impl;
Object proxy = proxiesByKey.get(key);
if ( proxy != null ) {
return narrowProxy(proxy, persister, key, impl);
}
else {
return impl;
}
|
| public java.lang.Object | proxyFor(java.lang.Object impl)Return the existing proxy associated with the given EntityKey, or the
argument (the entity associated with the key) if no proxy exists.
(slower than the form above)
EntityEntry e = getEntry(impl);
EntityPersister p = e.getPersister();
return proxyFor( p, new EntityKey( e.getId(), p, session.getEntityMode() ), impl );
|
| public boolean | reassociateIfUninitializedProxy(java.lang.Object value)Takes the given object and, if it represents a proxy, reassociates it with this event source.
if ( value instanceof ElementWrapper ) {
value = ( (ElementWrapper) value ).getElement();
}
if ( !Hibernate.isInitialized(value) ) {
HibernateProxy proxy = (HibernateProxy) value;
LazyInitializer li = proxy.getHibernateLazyInitializer();
reassociateProxy(li, proxy);
return true;
}
else {
return false;
}
|
| public void | reassociateProxy(java.lang.Object value, java.io.Serializable id)If a deleted entity instance is re-saved, and it has a proxy, we need to
reset the identifier of the proxy
if ( value instanceof ElementWrapper ) {
value = ( (ElementWrapper) value ).getElement();
}
if ( value instanceof HibernateProxy ) {
if ( log.isDebugEnabled() ) log.debug("setting proxy identifier: " + id);
HibernateProxy proxy = (HibernateProxy) value;
LazyInitializer li = proxy.getHibernateLazyInitializer();
li.setIdentifier(id);
reassociateProxy(li, proxy);
}
|
| private void | reassociateProxy(org.hibernate.proxy.LazyInitializer li, org.hibernate.proxy.HibernateProxy proxy)Associate a proxy that was instantiated by another session with this session
if ( li.getSession() != this.getSession() ) {
EntityPersister persister = session.getFactory().getEntityPersister( li.getEntityName() );
EntityKey key = new EntityKey( li.getIdentifier(), persister, session.getEntityMode() );
// any earlier proxy takes precedence
if ( !proxiesByKey.containsKey( key ) ) {
proxiesByKey.put( key, proxy );
}
proxy.getHibernateLazyInitializer().setSession( session );
}
|
| public org.hibernate.collection.PersistentCollection | removeCollectionHolder(java.lang.Object array)
return (PersistentCollection) arrayHolders.remove(array);
|
| public java.lang.Object | removeEntity(EntityKey key)Remove an entity from the session cache, also clear
up other state associated with the entity, all except
for the EntityEntry
Object entity = entitiesByKey.remove(key);
Iterator iter = entitiesByUniqueKey.values().iterator();
while ( iter.hasNext() ) {
if ( iter.next()==entity ) iter.remove();
}
entitySnapshotsByKey.remove(key);
nullifiableEntityKeys.remove(key);
getBatchFetchQueue().removeBatchLoadableEntityKey(key);
getBatchFetchQueue().removeSubselect(key);
return entity;
|
| public EntityEntry | removeEntry(java.lang.Object entity)Remove an entity entry from the session cache
return (EntityEntry) entityEntries.remove(entity);
|
| public java.lang.Object | removeProxy(EntityKey key)Remove a proxy from the session cache.
Additionally, ensure that any load optimization references
such as batch or subselect loading get cleaned up as well.
if ( batchFetchQueue != null ) {
batchFetchQueue.removeBatchLoadableEntityKey( key );
batchFetchQueue.removeSubselect( key );
}
return proxiesByKey.remove( key );
|
| public void | replaceDelayedEntityIdentityInsertKeys(EntityKey oldKey, java.io.Serializable generatedId)
Object entity = entitiesByKey.remove( oldKey );
EntityEntry oldEntry = ( EntityEntry ) entityEntries.remove( entity );
EntityKey newKey = new EntityKey( generatedId, oldEntry.getPersister(), getSession().getEntityMode() );
addEntity( newKey, entity );
addEntry(
entity,
oldEntry.getStatus(),
oldEntry.getLoadedState(),
oldEntry.getRowId(),
generatedId,
oldEntry.getVersion(),
oldEntry.getLockMode(),
oldEntry.isExistsInDatabase(),
oldEntry.getPersister(),
oldEntry.isBeingReplicated(),
oldEntry.isLoadedWithLazyPropertiesUnfetched()
);
|
| public void | serialize(java.io.ObjectOutputStream oos)Used by the owning session to explicitly control serialization of the
persistence context.
log.trace( "serializing persistent-context" );
oos.writeBoolean( hasNonReadOnlyEntities );
oos.writeInt( entitiesByKey.size() );
log.trace( "starting serialization of [" + entitiesByKey.size() + "] entitiesByKey entries" );
Iterator itr = entitiesByKey.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
( ( EntityKey ) entry.getKey() ).serialize( oos );
oos.writeObject( entry.getValue() );
}
oos.writeInt( entitiesByUniqueKey.size() );
log.trace( "starting serialization of [" + entitiesByUniqueKey.size() + "] entitiesByUniqueKey entries" );
itr = entitiesByUniqueKey.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
( ( EntityUniqueKey ) entry.getKey() ).serialize( oos );
oos.writeObject( entry.getValue() );
}
oos.writeInt( proxiesByKey.size() );
log.trace( "starting serialization of [" + proxiesByKey.size() + "] proxiesByKey entries" );
itr = proxiesByKey.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
( ( EntityKey ) entry.getKey() ).serialize( oos );
oos.writeObject( entry.getValue() );
}
oos.writeInt( entitySnapshotsByKey.size() );
log.trace( "starting serialization of [" + entitySnapshotsByKey.size() + "] entitySnapshotsByKey entries" );
itr = entitySnapshotsByKey.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
( ( EntityKey ) entry.getKey() ).serialize( oos );
oos.writeObject( entry.getValue() );
}
oos.writeInt( entityEntries.size() );
log.trace( "starting serialization of [" + entityEntries.size() + "] entityEntries entries" );
itr = entityEntries.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
oos.writeObject( entry.getKey() );
( ( EntityEntry ) entry.getValue() ).serialize( oos );
}
oos.writeInt( collectionsByKey.size() );
log.trace( "starting serialization of [" + collectionsByKey.size() + "] collectionsByKey entries" );
itr = collectionsByKey.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
( ( CollectionKey ) entry.getKey() ).serialize( oos );
oos.writeObject( entry.getValue() );
}
oos.writeInt( collectionEntries.size() );
log.trace( "starting serialization of [" + collectionEntries.size() + "] collectionEntries entries" );
itr = collectionEntries.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
oos.writeObject( entry.getKey() );
( ( CollectionEntry ) entry.getValue() ).serialize( oos );
}
oos.writeInt( arrayHolders.size() );
log.trace( "starting serialization of [" + arrayHolders.size() + "] arrayHolders entries" );
itr = arrayHolders.entrySet().iterator();
while ( itr.hasNext() ) {
Map.Entry entry = ( Map.Entry ) itr.next();
oos.writeObject( entry.getKey() );
oos.writeObject( entry.getValue() );
}
oos.writeInt( nullifiableEntityKeys.size() );
log.trace( "starting serialization of [" + nullifiableEntityKeys.size() + "] nullifiableEntityKeys entries" );
itr = nullifiableEntityKeys.iterator();
while ( itr.hasNext() ) {
EntityKey entry = ( EntityKey ) itr.next();
entry.serialize( oos );
}
|
| public void | setEntryStatus(EntityEntry entry, Status status)
entry.setStatus(status);
setHasNonReadOnlyEnties(status);
|
| public void | setFlushing(boolean flushing)
this.flushing = flushing;
|
| private void | setHasNonReadOnlyEnties(Status status)
if ( status==Status.DELETED || status==Status.MANAGED || status==Status.SAVING ) {
hasNonReadOnlyEntities = true;
}
|
| public void | setReadOnly(java.lang.Object entity, boolean readOnly)
EntityEntry entry = getEntry(entity);
if (entry==null) {
throw new TransientObjectException("Instance was not associated with the session");
}
entry.setReadOnly(readOnly, entity);
hasNonReadOnlyEntities = hasNonReadOnlyEntities || !readOnly;
|
| public java.lang.String | toString()Returns a string representation of the object.
return new StringBuffer()
.append("PersistenceContext[entityKeys=")
.append(entitiesByKey.keySet())
.append(",collectionKeys=")
.append(collectionsByKey.keySet())
.append("]")
.toString();
|
| public java.lang.Object | unproxy(java.lang.Object maybeProxy)Get the entity instance underlying the given proxy, throwing
an exception if the proxy is uninitialized. If the given object
is not a proxy, simply return the argument.
if ( maybeProxy instanceof ElementWrapper ) {
maybeProxy = ( (ElementWrapper) maybeProxy ).getElement();
}
if ( maybeProxy instanceof HibernateProxy ) {
HibernateProxy proxy = (HibernateProxy) maybeProxy;
LazyInitializer li = proxy.getHibernateLazyInitializer();
if ( li.isUninitialized() ) {
throw new PersistentObjectException(
"object was an uninitialized proxy for " +
li.getEntityName()
);
}
return li.getImplementation(); //unwrap the object
}
else {
return maybeProxy;
}
|
| public java.lang.Object | unproxyAndReassociate(java.lang.Object maybeProxy)Possibly unproxy the given reference and reassociate it with the current session.
if ( maybeProxy instanceof ElementWrapper ) {
maybeProxy = ( (ElementWrapper) maybeProxy ).getElement();
}
if ( maybeProxy instanceof HibernateProxy ) {
HibernateProxy proxy = (HibernateProxy) maybeProxy;
LazyInitializer li = proxy.getHibernateLazyInitializer();
reassociateProxy(li, proxy);
return li.getImplementation(); //initialize + unwrap the object
}
else {
return maybeProxy;
}
|
| public org.hibernate.collection.PersistentCollection | useUnownedCollection(CollectionKey key)
if (unownedCollections==null) {
return null;
}
else {
return (PersistentCollection) unownedCollections.remove(key);
}
|
