internal override object ProcessCollection(object collection, CollectionType type)
{
ISessionImplementor session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
if (collection == null)
{
//do nothing
}
else
{
IPersistentCollection persistentCollection = collection as IPersistentCollection;
if (persistentCollection != null)
{
if (persistentCollection.SetCurrentSession(session))
{
if (IsOwnerUnchanged(persistentCollection, persister, ExtractCollectionKeyFromOwner(persister)))
{
// a "detached" collection that originally belonged to the same entity
if (persistentCollection.IsDirty)
{
throw new HibernateException("reassociated object has dirty collection: " + persistentCollection.Role);
}
ReattachCollection(persistentCollection, type);
}
else
{
// a "detached" collection that belonged to a different entity
throw new HibernateException("reassociated object has dirty collection reference: " + persistentCollection.Role);
}
}
else
{
// a collection loaded in the current session
// can not possibly be the collection belonging
// to the entity passed to update()
throw new HibernateException("reassociated object has dirty collection reference: " + persistentCollection.Role);
}
}
else
{
// brand new collection
//TODO: or an array!! we can't lock objects with arrays now??
throw new HibernateException("reassociated object has dirty collection reference (or an array)");
}
}
return(null);
}
internal override object ProcessCollection(object collection, CollectionType collectionType)
{
IPersistentCollection coll = collection as IPersistentCollection;
if (coll != null)
{
ISessionImplementor session = Session;
if (coll.SetCurrentSession(session))
{
ReattachCollection(coll, collectionType);
}
return(null);
}
else
{
return(ProcessArrayOrNewCollection(collection, collectionType));
}
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection == CollectionType.UnfetchedCollection)
{
return(null);
}
IEventSource session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
object collectionKey = ExtractCollectionKeyFromOwner(persister);
IPersistentCollection wrapper = collection as IPersistentCollection;
if (wrapper != null)
{
if (wrapper.SetCurrentSession(session))
{
//a "detached" collection!
if (!IsOwnerUnchanged(wrapper, persister, collectionKey))
{
// if the collection belonged to a different entity,
// clean up the existing state of the collection
RemoveCollection(persister, collectionKey, session);
}
ReattachCollection(wrapper, type);
}
else
{
// a collection loaded in the current session
// can not possibly be the collection belonging
// to the entity passed to update()
RemoveCollection(persister, collectionKey, session);
}
}
else
{
// null or brand new collection
// this will also (inefficiently) handle arrays, which have
// no snapshot, so we can't do any better
RemoveCollection(persister, collectionKey, session);
}
return(null);
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection == CollectionType.UnfetchedCollection)
{
return(null);
}
IEventSource session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
if (isUpdate)
{
RemoveCollection(persister, ExtractCollectionKeyFromOwner(persister), session);
}
IPersistentCollection wrapper = collection as IPersistentCollection;
if (wrapper != null)
{
wrapper.SetCurrentSession(session);
if (wrapper.WasInitialized)
{
session.PersistenceContext.AddNewCollection(persister, wrapper);
}
else
{
ReattachCollection(wrapper, type);
}
}
else
{
// otherwise a null or brand new collection
// this will also (inefficiently) handle arrays, which
// have no snapshot, so we can't do any better
//processArrayOrNewCollection(collection, type);
}
return(null);
}
/// <summary>
/// Checks if the collection is still associated with it's session and is not initialized.
/// Creates a new one if it is not.
/// </summary>
/// <param name="collection">The collection to check.</param>
/// <param name="initialized">Is the collection initialized yet.</param>
/// <param name="Session">The session to which the collection is linked.</param>
/// <param name="sessionConfirmed">Used to remember if this method has already created a new session for this collection.</param>
/// <returns>The newly created session, if one is required.</returns>
internal static ISession checkSession(this IPersistentCollection collection, bool initialized, ISessionImplementor Session, ref bool sessionConfirmed)
{
if (sessionConfirmed)
{
return(null);
}
if (!initialized)
{
//If the session has been disconnected, reconnect before continuing with the initialization.
if (Session == null ||
!Session.IsOpen ||
!Session.PersistenceContext.ContainsCollection(collection) ||
!Session.IsConnected)
{
var ret = ActiveRecordMediator.GetSessionFactoryHolder().CreateSession(collection.Owner.GetType());
sessionConfirmed = true;
collection.SetCurrentSession(ret.GetSessionImplementation());
ret.Lock(collection.Owner, LockMode.None);
return(ret);
}
}
return(null);
}