public TruncateState(SyncContainer owner) : base(owner)
{
foreach (SyncContainer sc in StateOwner.Children)
{
sc.Truncate();
}
}
protected override void SynchronizeImpl()
{
ISerializableObject source = StateOwner.SourceObject;
ISerializableObject sink = StateOwner.SinkSerializer.CreateISerializableObject(StateOwner.SynchronizedType);
CopyUtils.PlainCopy(StateOwner.SinkSerializer, KeyCarrier, sink, new FieldLock(source.GetType()), true);
CopyUtils.PlainCopy(StateOwner.SinkSerializer, source, sink, new FieldLock(source.GetType()), false);
StateOwner.SinkSerializer.Connector.InsertPlain(sink);
StateOwner.SinkObject = sink;
SyncItem si1 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>();
SyncItem si2 = StateOwner.SyncSerializer.CreateISerializableObject <SyncItem>();
si1.SyncGuid = AttributeWorker.RowGuid(source);
si2.SyncGuid = AttributeWorker.RowGuid(sink);
si1.ClassID = source.GetType().Name;
si2.ClassID = source.GetType().Name;
si1.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source);
si2.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink);
si1.CounterPart = si2;
StateOwner.SyncSerializer.Connector.Save(si1);
StateOwner.SyncSerializer.ConnectOneToOne(si1, si2);
StateOwner.SyncSerializer.Connector.Save(si2);
StateOwner.SyncSerializer.ConnectOneToOne(si2, si1);
StateOwner.SyncSerializer.Connector.Save(si1);
StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, si1, source);//Deaktiviert
StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, si2, sink);
}
protected override void SynchronizeImpl()
{
ISerializableObject source = StateOwner.SourceObject;
ISerializableObject sink = StateOwner.SinkObject;
CopyUtils.ForeignKeyCopy(StateOwner.SinkSerializer, KeyCarrier, sink, base._fieldLock);
//Kopiere die angepassten Daten...
CopyUtils.PlainCopy(StateOwner.SinkSerializer, _resolved, sink, base._fieldLock, false);
CopyUtils.PlainCopy(StateOwner.SourceSerializer, _resolved, source, base._fieldLock, false);
StateOwner.SinkSerializer.Connector.UpdatePlain(sink);
StateOwner.SourceSerializer.Connector.UpdatePlain(source);
_sourceSyncItem.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source);
StateOwner.SyncSerializer.Connector.Save(_sourceSyncItem);
SyncItem tmp = _sourceSyncItem.CounterPart;
tmp.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink);
StateOwner.SyncSerializer.Connector.Save(tmp);
StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, _sourceSyncItem, source);
StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, tmp, sink);
}
internal TruncateState(SyncContainer owner, SyncState previous)
: base(owner, previous)
{
foreach (SyncContainer sc in StateOwner.Children)
{
sc.Truncate();
}
}
internal void AddISerializableObject(ISerializableObject iso)
{
if (!_pooledObjects.ContainsKey(AttributeWorker.RowGuid(iso)))
{
SyncContainer container = new SyncContainer(iso, _syncSerializer, _serializer);
_pooledObjects[AttributeWorker.RowGuid(iso)] = container;
}
}
protected override void SynchronizeImpl()
{
ISerializableObject source = StateOwner.SourceObject;
ISerializableObject sink = StateOwner.SinkObject;
CopyUtils.PlainCopy(StateOwner.SinkSerializer, KeyCarrier, sink, _fieldLock, true);
CopyUtils.PlainCopy(StateOwner.SinkSerializer, source, sink, _fieldLock, false);
StateOwner.SinkSerializer.Connector.UpdatePlain(sink);
_sourceSyncItem.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SourceSerializer.Target, source);
StateOwner.SyncSerializer.Connector.Save(_sourceSyncItem);
SyncItem sinkSyncItem = _sourceSyncItem.CounterPart;
sinkSyncItem.Hashcode = SyncContainer.ComputeHashCode(StateOwner.SinkSerializer.Target, sink);
StateOwner.SyncSerializer.Connector.Save(sinkSyncItem);
StateOwner.UpdateFieldStates(StateOwner.SourceSerializer.Target, _sourceSyncItem, source);
StateOwner.UpdateFieldStates(StateOwner.SinkSerializer.Target, sinkSyncItem, sink);
}
internal void StartSynchronizing(SyncTool syncPeer)
{
if (!_initialized)
{
throw new SyncException("Syncpool is not initialized!");
}
if (!CheckSyncContext(syncPeer))
{
throw new SyncException("SyncPool is not compatible with SyncPeer!");
}
if (!CheckTarget(syncPeer))
{
throw new SyncException("Synchronising form source to source is not valid!");
}
_syncSerializer.Connector.BeginTransaction();
syncPeer.Serializer.Connector.BeginTransaction();
SyncContainer lastContainer = null;
try
{
foreach (SyncContainer c in _pooledObjects.Values)
{
lastContainer = c;
c.Synchronize();
}
_syncSerializer.Connector.Commit();
syncPeer.Serializer.Connector.Commit();
}
catch (Exception ex)
{
ResetSynchronizedState();
if (!OnSynchronizeEvent(new SynchronizeEventArgs()))
{
throw new Exception("Synchronizing failed at: " + lastContainer, ex);
}
}
}
public void HandleOneToMany(ISerializableObject handledItem, OneToManyAttribute attr, FieldInfo field)
{
IEnumerable set = (IEnumerable)field.GetValue(handledItem);
foreach (ISerializableObject iso in set)
{
try
{
SyncContainer s = _pooledObjects[AttributeWorker.RowGuid(iso)];
if (!_owner._children.Contains(s))
{
_owner._children.Add(s);
}
if (!s._parents.Contains(_owner))
{
s._parents.Add(_owner);
}
}
catch (KeyNotFoundException)
{
}
}
}
public void HandleManyToOne(ISerializableObject handledItem, ManyToOneAttribute attr, FieldInfo field)
{
ISerializableObject iso = (ISerializableObject)field.GetValue(handledItem);
if (iso != null)
{
try
{
SyncContainer s = _pooledObjects[AttributeWorker.RowGuid(iso)];
if (!_owner._parents.Contains(s))
{
_owner._parents.Add(s);
}
if (!s._children.Contains(_owner))
{
s._children.Add(_owner);
}
}
catch (KeyNotFoundException)
{
}
}
}
public DependencyRelationHandler(SyncContainer owner, IDictionary <Guid, SyncContainer> pooledObjects)
{
_pooledObjects = pooledObjects;
_owner = owner;
}
public PrematureState(SyncContainer owner)
: base(owner)
{
}
internal SynchronizedState(SyncContainer owner, SyncState previous)
: base(owner, previous)
{
}
public DeletedState(SyncContainer owner, SyncItem sourceSyncItem)
: base(owner, sourceSyncItem)
{
}
public ConflictState(SyncContainer owner, SyncItem sourceSyncItem) : base(owner)
{
_sourceSyncItem = sourceSyncItem;
}
internal WritingStates(SyncContainer owner, SyncState previous)
: base(owner, previous)
{
_doSynchronizing = true;
}
public ConflictResolvedState(SyncContainer owner, ISerializableObject resolved, SyncItem sourceSyncItem)
: base(owner, sourceSyncItem)
{
_resolved = resolved;
}
internal IgnoreState(SyncContainer owner, SyncState previous)
: base(owner, previous)
{
}
internal UpdateState(SyncContainer owner, SyncItem sourceSyncItem, SyncState previous)
: base(owner, previous)
{
_sourceSyncItem = sourceSyncItem;
_fieldLock = new FieldLock(_sourceSyncItem.GetType());
}
public UpdateState(SyncContainer owner, SyncItem sourceSyncItem)
: base(owner)
{
_sourceSyncItem = sourceSyncItem;
_fieldLock = new FieldLock(_sourceSyncItem.GetType());
}
internal SyncState(SyncContainer owner, SyncState previousState)
{
_StateOwner = owner;
_PreviousState = previousState;
}
public InsertState(SyncContainer owner)
: base(owner)
{
}
internal ConflictResolvedState(SyncContainer owner, ISerializableObject resolved, SyncItem sourceSyncItem, SyncState previous)
: base(owner, sourceSyncItem, previous)
{
_resolved = resolved;
}
public SyncState(SyncContainer owner)
{
_StateOwner = owner;
_PreviousState = null;
}
public IgnoreState(SyncContainer owner)
: base(owner)
{
}
public WritingStates(SyncContainer owner)
: base(owner)
{
_doSynchronizing = true;
}