public override void Process(object obj, IClassPersister persister)
{
object[] values = persister.GetPropertyValues(obj);
IType[] types = persister.PropertyTypes;
ProcessValues(values, types);
if (IsSubstitutionRequired)
{
persister.SetPropertyValues(obj, values);
}
}
/// <summary>
///
/// </summary>
/// <param name="values"></param>
/// <param name="result"></param>
/// <param name="id"></param>
/// <param name="persister"></param>
/// <param name="session"></param>
/// <returns></returns>
private static object[] Assemble(object[] values, object result, object id, IClassPersister persister, IInterceptor interceptor, ISessionImplementor session)
{
IType[] propertyTypes = persister.PropertyTypes;
object[] assembledProps = new object[propertyTypes.Length];
for (int i = 0; i < values.Length; i++)
{
assembledProps[i] = propertyTypes[i].Assemble(values[i], session, result);
}
interceptor.OnLoad(result, id, assembledProps, persister.PropertyNames, propertyTypes);
persister.SetPropertyValues(result, assembledProps);
if (persister.ImplementsLifecycle)
{
(( ILifecycle )result).OnLoad(session, id);
}
return(assembledProps);
}
public override void Process(object obj, IClassPersister persister)
{
object[] values = persister.GetPropertyValues( obj );
IType[] types = persister.PropertyTypes;
ProcessValues( values, types );
if( IsSubstitutionRequired )
{
persister.SetPropertyValues( obj, values );
}
}
private object DoSave(
object theObj,
Key key,
IClassPersister persister,
bool replicate,
bool useIdentityColumn,
Cascades.CascadingAction cascadeAction,
object anything )
{
if( persister.ImplementsValidatable )
{
( ( IValidatable ) theObj ).Validate();
}
object id;
if( useIdentityColumn )
{
id = null;
ExecuteInserts();
}
else
{
id = key.Identifier;
}
// Put a placeholder in entries, so we don't recurse back to try and Save() the
// same object again. QUESTION: Should this be done before OnSave() is called?
// likewise, should it be done before OnUpdate()?
AddEntry( theObj, Status.Saving, null, id, null, LockMode.Write, useIdentityColumn, persister, false ); // okay if id is null here
// cascade-save to many-to-one BEFORE the parent is saved
cascading++;
try
{
Cascades.Cascade( this, persister, theObj, cascadeAction, CascadePoint.CascadeBeforeInsertAfterDelete, anything );
}
finally
{
cascading--;
}
object[ ] values = persister.GetPropertyValues( theObj );
IType[ ] types = persister.PropertyTypes;
bool substitute = false;
if( !replicate )
{
substitute = interceptor.OnSave( theObj, id, values, persister.PropertyNames, types );
// Keep the existing version number in the case of replicate!
if( persister.IsVersioned )
{
// IsUnsavedVersion bit below is NHibernate-specific
substitute = Versioning.SeedVersion(
values, persister.VersionProperty, persister.VersionType, persister.IsUnsavedVersion( values )
) || substitute;
}
}
if( persister.HasCollections )
{
// TODO: make OnReplicateVisitor extend WrapVisitor
if( replicate )
{
OnReplicateVisitor visitor = new OnReplicateVisitor( this, id );
visitor.ProcessValues( values, types );
}
WrapVisitor visitor2 = new WrapVisitor( this );
// substitutes into values by side-effect
visitor2.ProcessValues( values, types );
substitute = substitute || visitor2.IsSubstitutionRequired;
}
if( substitute )
{
persister.SetPropertyValues( theObj, values );
}
TypeFactory.DeepCopy( values, types, persister.PropertyUpdateability, values );
NullifyTransientReferences( values, types, useIdentityColumn, theObj );
CheckNullability( values, persister, false );
if( useIdentityColumn )
{
ScheduledIdentityInsertion insert = new ScheduledIdentityInsertion( values, theObj, persister, this );
Execute( insert );
id = insert.GeneratedId;
persister.SetIdentifier( theObj, id );
key = new Key( id, persister );
CheckUniqueness( key, theObj );
}
object version = Versioning.GetVersion( values, persister );
AddEntity( key, theObj );
AddEntry( theObj, Status.Loaded, values, id, version, LockMode.Write, useIdentityColumn, persister, replicate );
nonExists.Remove( key );
if( !useIdentityColumn )
{
insertions.Add( new ScheduledInsertion( id, values, theObj, version, persister, this ) );
}
// cascade-save to collections AFTER the collection owner was saved
cascading++;
try
{
Cascades.Cascade( this, persister, theObj, cascadeAction, CascadePoint.CascadeAfterInsertBeforeDelete, anything );
}
finally
{
cascading--;
}
return id;
}
/// <summary>
///
/// </summary>
/// <param name="values"></param>
/// <param name="result"></param>
/// <param name="id"></param>
/// <param name="persister"></param>
/// <param name="session"></param>
/// <returns></returns>
private static object[ ] Assemble( object[ ] values, object result, object id, IClassPersister persister, IInterceptor interceptor, ISessionImplementor session )
{
IType[ ] propertyTypes = persister.PropertyTypes;
object[ ] assembledProps = new object[propertyTypes.Length];
for( int i = 0; i < values.Length; i++ )
{
assembledProps[ i ] = propertyTypes[ i ].Assemble( values[ i ], session, result );
}
interceptor.OnLoad( result, id, assembledProps, persister.PropertyNames, propertyTypes );
persister.SetPropertyValues( result, assembledProps );
if( persister.ImplementsLifecycle )
{
( ( ILifecycle ) result ).OnLoad( session, id );
}
return assembledProps;
}
