private void CopyStateAcross(object source, object dest, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
IReflectClass claxx = _reflector.ForObject(source);
CopyFieldValuesAcross(source, dest, claxx, sourceProvider, targetProvider);
}
public _IVisitor4_182(GenericReplicationSession _enclosing, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
this._enclosing = _enclosing;
this.sourceProvider = sourceProvider;
this.targetProvider = targetProvider;
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
if (dest == null)
{
throw new InvalidOperationException("Dest cannot be null: src=" + src + ", class="
+ claxx + ", source=" + sourceProvider.GetName() + ", target=" + targetProvider
.GetName());
}
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
public _ICounterpartFinder_248(GenericReplicationSession _enclosing, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
this._enclosing = _enclosing;
this.sourceProvider = sourceProvider;
this.targetProvider = targetProvider;
}
private object EmptyClone(IReplicationProviderInside sourceProvider, object obj)
{
if (obj == null)
{
return(null);
}
IReflectClass claxx = ReflectClass(obj);
if (_reflector.IsValueType(claxx))
{
throw new Exception("IllegalState");
}
// if (claxx.isArray()) return arrayClone(obj, claxx, sourceProvider); //Copy arrayClone() from GenericReplicationSession if necessary.
if (claxx.IsArray())
{
throw new Exception("IllegalState");
}
//Copy arrayClone() from GenericReplicationSession if necessary.
if (_collectionHandler.CanHandleClass(claxx))
{
return(CollectionClone(sourceProvider, obj, claxx));
}
object result = claxx.NewInstance();
if (result == null)
{
throw new Exception("Unable to create a new instance of " + obj.GetType());
}
//FIXME Use db4o's standard for throwing exceptions.
return(result);
}
private bool HandleNewObject(object obj, IReplicationReference ownerRef, IReplicationProviderInside
owner, IReplicationProviderInside other, object referencingObject, string fieldName
, bool needsToBeActivated, bool listenerAlreadyNotified)
{
if (_directionTo == owner)
{
return(false);
}
if (needsToBeActivated)
{
owner.Activate(obj);
}
if (!listenerAlreadyNotified)
{
_event.ResetAction();
_event.Conflict(false);
_event._creationDate = TimeStampIdGenerator.IdToMilliseconds(ownerRef.Uuid().GetLongPart
());
if (owner == _providerA)
{
_stateInA.SetAll(obj, true, false, ObjectStateImpl.Unknown);
_stateInB.SetAll(null, false, false, ObjectStateImpl.Unknown);
}
else
{
_stateInA.SetAll(null, false, false, ObjectStateImpl.Unknown);
_stateInB.SetAll(obj, true, false, ObjectStateImpl.Unknown);
}
if (_listener != null)
{
_listener.OnReplicate(_event);
if (_event._actionWasChosen)
{
if (_event._actionChosenState == null)
{
return(false);
}
if (_event._actionChosenState.GetObject() != obj)
{
return(false);
}
}
}
}
object counterpart = EmptyClone(owner, obj);
ownerRef.SetCounterpart(counterpart);
ownerRef.MarkForReplicating(true);
IReplicationReference otherRef = other.ReferenceNewObject(counterpart, ownerRef,
GetCounterpartRef(referencingObject), fieldName);
otherRef.SetCounterpart(obj);
PutCounterpartRef(obj, otherRef);
if (_event._actionShouldStopTraversal)
{
return(false);
}
return(true);
}
public void Close()
{
_providerA.Destroy();
_providerB.Destroy();
_providerA = null;
_providerB = null;
_processedUuids = null;
}
public void Close()
{
_providerA.Destroy();
_providerB.Destroy();
_providerA = null;
_providerB = null;
_processedUuids = null;
}
private void DeleteInDestination(IReplicationReference reference, IReplicationProviderInside
destination)
{
if (!reference.IsMarkedForDeleting())
{
return;
}
destination.ReplicateDeletion(reference.Uuid());
}
private object FindCounterpart(object value, IReplicationProviderInside sourceProvider
, IReplicationProviderInside targetProvider)
{
if (value == null)
{
return(null);
}
value = sourceProvider.ReplaceIfSpecific(value);
// TODO: need to clone and findCounterpart of each reference object in the
// struct
if (ReplicationPlatform.IsValueType(value))
{
return(value);
}
IReflectClass claxx = _reflector.ForObject(value);
if (claxx.IsArray())
{
return(ArrayClone(value, claxx, sourceProvider, targetProvider));
}
if (Platform4.IsTransient(claxx))
{
return(null);
}
// TODO: make it a warning
if (_reflector.IsValueType(claxx))
{
return(value);
}
if (_collectionHandler.CanHandle(value))
{
return(CollectionClone(value, claxx, sourceProvider, targetProvider));
}
//if value is a Collection, result should be found by passing in just the value
IReplicationReference @ref = sourceProvider.ProduceReference(value, null, null);
if (@ref == null)
{
throw new InvalidOperationException("unable to find the ref of " + value + " of class "
+ value.GetType());
}
object result = @ref.Counterpart();
if (result != null)
{
return(result);
}
IReplicationReference targetRef = targetProvider.ProduceReferenceByUUID(@ref.Uuid
(), value.GetType());
if (targetRef == null)
{
throw new InvalidOperationException("unable to find the counterpart of " + value
+ " of class " + value.GetType());
}
return(targetRef.Object());
}
private void CopyStateAcross(IReplicationProviderInside sourceProvider, IReplicationProviderInside
targetProvider)
{
if (_directionTo == sourceProvider)
{
return;
}
sourceProvider.VisitCachedReferences(new _IVisitor4_182(this, sourceProvider, targetProvider
));
}
private void CopyStateAcross(IReplicationReference sourceRef, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
if (!sourceRef.IsMarkedForReplicating())
{
return;
}
CopyStateAcross(sourceRef.Object(), sourceRef.Counterpart(), sourceProvider, targetProvider
);
}
private void StoreChangedObjectsIn(IReplicationProviderInside destination)
{
IReplicationProviderInside source = Other(destination);
if (_directionTo == source)
{
return;
}
destination.VisitCachedReferences(new _IVisitor4_280(this, destination));
source.VisitCachedReferences(new _IVisitor4_286(this, destination));
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
RunIsolated(new _IBlock4_73(this));
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
RunIsolated(new _IBlock4_73(this));
}
private void ReplaceWithCounterparts(object[] objects, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
for (int i = 0; i < objects.Length; i++)
{
object @object = objects[i];
if (@object == null)
{
continue;
}
objects[i] = FindCounterpart(@object, sourceProvider, targetProvider);
}
}
private void StoreChangedCounterpartInDestination(IReplicationReference reference
, IReplicationProviderInside destination)
{
//System.out.println("reference = " + reference);
bool markedForReplicating = reference.IsMarkedForReplicating();
//System.out.println("markedForReplicating = " + markedForReplicating);
if (!markedForReplicating)
{
return;
}
destination.StoreReplica(reference.Counterpart());
}
private void ReplicateDeletions(Type extent, IReplicationProviderInside provider)
{
_isReplicatingOnlyDeletions = true;
try
{
IEnumerator instances = provider.GetStoredObjects(extent).GetEnumerator();
while (instances.MoveNext())
{
Replicate(instances.Current);
}
}
finally
{
_isReplicatingOnlyDeletions = false;
}
}
private object ArrayClone(object original, IReflectClass claxx, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
IReflectClass componentType = _reflector.GetComponentType(claxx);
int[] dimensions = _reflector.ArrayDimensions(original);
object result = _reflector.NewArrayInstance(componentType, dimensions);
object[] flatContents = _reflector.ArrayContents(original);
//TODO Optimize: Copy the structure without flattening. Do this in ReflectArray.
if (!(_reflector.IsValueType(claxx) || _reflector.IsValueType(componentType)))
{
ReplaceWithCounterparts(flatContents, sourceProvider, targetProvider);
}
_reflector.ArrayShape(flatContents, 0, result, dimensions, 0);
return(result);
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
_providerA.StartReplicationTransaction(_providerB.GetSignature());
_providerB.StartReplicationTransaction(_providerA.GetSignature());
long syncedTimeStamp = Math.Max(_providerA.TimeStamps().Commit(), _providerB.TimeStamps
().Commit());
_providerA.SyncCommitTimestamp(syncedTimeStamp);
_providerB.SyncCommitTimestamp(syncedTimeStamp);
}
public GenericReplicationSession(IReplicationProvider providerA, IReplicationProvider
providerB, IReplicationEventListener listener, IReflector reflector)
{
//null means bidirectional replication.
_reflector = new ReplicationReflector(providerA, providerB, reflector);
_collectionHandler = new CollectionHandlerImpl(_reflector);
_traverser = new GenericTraverser(_reflector, _collectionHandler);
_providerA = (IReplicationProviderInside)providerA;
_providerB = (IReplicationProviderInside)providerB;
_listener = listener;
_providerA.StartReplicationTransaction(_providerB.GetSignature());
_providerB.StartReplicationTransaction(_providerA.GetSignature());
long syncedTimeStamp = Math.Max(_providerA.TimeStamps().Commit(), _providerB.TimeStamps
().Commit());
_providerA.SyncCommitTimestamp(syncedTimeStamp);
_providerB.SyncCommitTimestamp(syncedTimeStamp);
}
internal InstanceReplicationPreparer(IReplicationProviderInside providerA, IReplicationProviderInside
providerB, IReplicationProvider directionTo, IReplicationEventListener listener
, bool isReplicatingOnlyDeletions, HashSet4 uuidsProcessedInSession, ITraverser
traverser, ReplicationReflector reflector, Db4objects.Drs.Inside.ICollectionHandler
collectionHandler)
{
_event = new ReplicationEventImpl();
_stateInA = _event._stateInProviderA;
_stateInB = _event._stateInProviderB;
_providerA = providerA;
_providerB = providerB;
_directionTo = directionTo;
_listener = listener;
_isReplicatingOnlyDeletions = isReplicatingOnlyDeletions;
_uuidsProcessedInSession = uuidsProcessedInSession;
_traverser = traverser;
_reflector = reflector;
_collectionHandler = collectionHandler;
}
internal InstanceReplicationPreparer(IReplicationProviderInside providerA, IReplicationProviderInside
providerB, IReplicationProvider directionTo, IReplicationEventListener listener
, bool isReplicatingOnlyDeletions, long lastReplicationVersion, HashSet4 uuidsProcessedInSession
, ITraverser traverser, ReplicationReflector reflector, Db4objects.Drs.Inside.ICollectionHandler
collectionHandler)
{
_event = new ReplicationEventImpl();
_stateInA = _event._stateInProviderA;
_stateInB = _event._stateInProviderB;
_providerA = providerA;
_providerB = providerB;
_directionTo = directionTo;
_listener = listener;
_isReplicatingOnlyDeletions = isReplicatingOnlyDeletions;
_lastReplicationVersion = lastReplicationVersion;
_uuidsProcessedInSession = uuidsProcessedInSession;
_traverser = traverser;
_reflector = reflector;
_collectionHandler = collectionHandler;
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
private void CopyStateAcross(IReplicationReference sourceRef, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
if (!sourceRef.IsMarkedForReplicating())
{
return;
}
object source = sourceRef.Object();
object target = sourceRef.Counterpart();
if (source == null)
{
throw new InvalidOperationException("source may not be null");
}
if (target == null)
{
throw new InvalidOperationException("target may not be null");
}
CopyStateAcross(source, target, sourceProvider, targetProvider);
}
private IReplicationProviderInside Other(IReplicationProviderInside peer)
{
return(peer == _providerA ? _providerB : _providerA);
}
private bool HandleMissingObjectInOther(object obj, IReplicationReference ownerRef
, IReplicationProviderInside owner, IReplicationProviderInside other, object referencingObject
, string fieldName)
{
bool isConflict = false;
bool wasModified = owner.WasModifiedSinceLastReplication(ownerRef);
if (wasModified)
{
isConflict = true;
}
if (_directionTo == other)
{
isConflict = true;
}
object prevailing = null;
//by default, deletion prevails
if (isConflict)
{
owner.Activate(obj);
}
_event.ResetAction();
_event._isConflict = isConflict;
_event._creationDate = TimeStampIdGenerator.IdToMilliseconds(ownerRef.Uuid().GetLongPart
());
long modificationDate = TimeStampIdGenerator.IdToMilliseconds(ownerRef.Version());
if (owner == _providerA)
{
_stateInA.SetAll(obj, false, wasModified, modificationDate);
_stateInB.SetAll(null, false, false, -1);
}
else
{
//owner == _providerB
_stateInA.SetAll(null, false, false, -1);
_stateInB.SetAll(obj, false, wasModified, modificationDate);
}
_listener.OnReplicate(_event);
if (isConflict && !_event._actionWasChosen)
{
ThrowReplicationConflictException();
}
if (_event._actionWasChosen)
{
if (_event._actionChosenState == null)
{
return false;
}
if (_event._actionChosenState == _stateInA)
{
prevailing = _stateInA.GetObject();
}
if (_event._actionChosenState == _stateInB)
{
prevailing = _stateInB.GetObject();
}
}
if (prevailing == null)
{
//Deletion has prevailed.
if (_directionTo == other)
{
return false;
}
ownerRef.MarkForDeleting();
return !_event._actionShouldStopTraversal;
}
bool needsToBeActivated = !isConflict;
//Already activated if there was a conflict.
return HandleNewObject(obj, ownerRef, owner, other, referencingObject, fieldName,
needsToBeActivated, true);
}
public GenericReplicationSession(IReplicationProviderInside _peerA, IReplicationProviderInside
_peerB) : this(_peerA, _peerB, new DefaultReplicationEventListener())
{
}
private object EmptyClone(IReplicationProviderInside sourceProvider, object obj)
{
if (obj == null)
{
return null;
}
IReflectClass claxx = ReflectClass(obj);
if (_reflector.IsValueType(claxx))
{
throw new Exception("IllegalState");
}
// if (claxx.isArray()) return arrayClone(obj, claxx, sourceProvider); //Copy arrayClone() from GenericReplicationSession if necessary.
if (claxx.IsArray())
{
throw new Exception("IllegalState");
}
//Copy arrayClone() from GenericReplicationSession if necessary.
if (_collectionHandler.CanHandleClass(claxx))
{
return CollectionClone(sourceProvider, obj, claxx);
}
object result = claxx.NewInstance();
if (result == null)
{
throw new Exception("Unable to create a new instance of " + obj.GetType());
}
//FIXME Use db4o's standard for throwing exceptions.
return result;
}
private object CollectionClone(object original, IReflectClass claxx, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
return(_collectionHandler.CloneWithCounterparts(sourceProvider, original, claxx,
new _ICounterpartFinder_248(this, sourceProvider, targetProvider)));
}
private object CollectionClone(object original, IReflectClass claxx, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
return _collectionHandler.CloneWithCounterparts(sourceProvider, original, claxx,
new _ICounterpartFinder_248(this, sourceProvider, targetProvider));
}
public _ICounterpartFinder_248(GenericReplicationSession _enclosing, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
this._enclosing = _enclosing;
this.sourceProvider = sourceProvider;
this.targetProvider = targetProvider;
}
private void CopyStateAcross(IReplicationReference sourceRef, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
if (!sourceRef.IsMarkedForReplicating())
{
return;
}
CopyStateAcross(sourceRef.Object(), sourceRef.Counterpart(), sourceProvider, targetProvider
);
}
private object CollectionClone(IReplicationProviderInside sourceProvider, object
original, IReflectClass claxx)
{
return(_collectionHandler.EmptyClone(sourceProvider, original, claxx));
}
private void StoreChangedObjectsIn(IReplicationProviderInside destination)
{
IReplicationProviderInside source = Other(destination);
if (_directionTo == source)
{
return;
}
destination.VisitCachedReferences(new _IVisitor4_280(this, destination));
source.VisitCachedReferences(new _IVisitor4_286(this, destination));
}
private void StoreChangedCounterpartInDestination(IReplicationReference reference
, IReplicationProviderInside destination)
{
//System.out.println("reference = " + reference);
bool markedForReplicating = reference.IsMarkedForReplicating();
//System.out.println("markedForReplicating = " + markedForReplicating);
if (!markedForReplicating)
{
return;
}
destination.StoreReplica(reference.Counterpart());
}
private void ReplaceWithCounterparts(object[] objects, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
for (int i = 0; i < objects.Length; i++)
{
object @object = objects[i];
if (@object == null)
{
continue;
}
objects[i] = FindCounterpart(@object, sourceProvider, targetProvider);
}
}
private object ArrayClone(object original, IReflectClass claxx, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
IReflectClass componentType = _reflector.GetComponentType(claxx);
int[] dimensions = _reflector.ArrayDimensions(original);
object result = _reflector.NewArrayInstance(componentType, dimensions);
object[] flatContents = _reflector.ArrayContents(original);
//TODO Optimize: Copy the structure without flattening. Do this in ReflectArray.
if (!(_reflector.IsValueType(claxx) || _reflector.IsValueType(componentType)))
{
ReplaceWithCounterparts(flatContents, sourceProvider, targetProvider);
}
_reflector.ArrayShape(flatContents, 0, result, dimensions, 0);
return result;
}
private object FindCounterpart(object value, IReplicationProviderInside sourceProvider
, IReplicationProviderInside targetProvider)
{
if (value == null)
{
return null;
}
value = sourceProvider.ReplaceIfSpecific(value);
// TODO: need to clone and findCounterpart of each reference object in the
// struct
if (ReplicationPlatform.IsValueType(value))
{
return value;
}
IReflectClass claxx = _reflector.ForObject(value);
if (claxx.IsArray())
{
return ArrayClone(value, claxx, sourceProvider, targetProvider);
}
if (Platform4.IsTransient(claxx))
{
return null;
}
// TODO: make it a warning
if (_reflector.IsValueType(claxx))
{
return value;
}
if (_collectionHandler.CanHandle(value))
{
return CollectionClone(value, claxx, sourceProvider, targetProvider);
}
//if value is a Collection, result should be found by passing in just the value
IReplicationReference @ref = sourceProvider.ProduceReference(value, null, null);
if (@ref == null)
{
throw new InvalidOperationException("unable to find the ref of " + value + " of class "
+ value.GetType());
}
object result = @ref.Counterpart();
if (result != null)
{
return result;
}
IReplicationReference targetRef = targetProvider.ProduceReferenceByUUID(@ref.Uuid
(), value.GetType());
if (targetRef == null)
{
throw new InvalidOperationException("unable to find the counterpart of " + value
+ " of class " + value.GetType());
}
return targetRef.Object();
}
private void ReplicateDeletions(Type extent, IReplicationProviderInside provider)
{
_isReplicatingOnlyDeletions = true;
try
{
IEnumerator instances = provider.GetStoredObjects(extent).GetEnumerator();
while (instances.MoveNext())
{
Replicate(instances.Current);
}
}
finally
{
_isReplicatingOnlyDeletions = false;
}
}
private void DeleteInDestination(IReplicationReference reference, IReplicationProviderInside
destination)
{
if (!reference.IsMarkedForDeleting())
{
return;
}
destination.ReplicateDeletion(reference.Uuid());
}
private object CollectionClone(IReplicationProviderInside sourceProvider, object
original, IReflectClass claxx)
{
return _collectionHandler.EmptyClone(sourceProvider, original, claxx);
}
private void CopyStateAcross(object source, object dest, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
IReflectClass claxx = _reflector.ForObject(source);
CopyFieldValuesAcross(source, dest, claxx, sourceProvider, targetProvider);
}
public _IVisitor4_286(GenericReplicationSession _enclosing, IReplicationProviderInside
destination)
{
this._enclosing = _enclosing;
this.destination = destination;
}
private void CopyStateAcross(IReplicationReference sourceRef, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
if (!sourceRef.IsMarkedForReplicating())
{
return;
}
object source = sourceRef.Object();
object target = sourceRef.Counterpart();
if (source == null)
{
throw new InvalidOperationException("source may not be null");
}
if (target == null)
{
throw new InvalidOperationException("target may not be null");
}
CopyStateAcross(source, target, sourceProvider, targetProvider);
}
private bool HandleNewObject(object obj, IReplicationReference ownerRef, IReplicationProviderInside
owner, IReplicationProviderInside other, object referencingObject, string fieldName
, bool needsToBeActivated, bool listenerAlreadyNotified)
{
if (_directionTo == owner)
{
return false;
}
if (needsToBeActivated)
{
owner.Activate(obj);
}
if (!listenerAlreadyNotified)
{
_event.ResetAction();
_event._isConflict = false;
_event._creationDate = TimeStampIdGenerator.IdToMilliseconds(ownerRef.Uuid().GetLongPart
());
if (owner == _providerA)
{
_stateInA.SetAll(obj, true, false, -1);
_stateInB.SetAll(null, false, false, -1);
}
else
{
_stateInA.SetAll(null, false, false, -1);
_stateInB.SetAll(obj, true, false, -1);
}
if (_listener != null)
{
_listener.OnReplicate(_event);
if (_event._actionWasChosen)
{
if (_event._actionChosenState == null)
{
return false;
}
if (_event._actionChosenState.GetObject() != obj)
{
return false;
}
}
}
}
object counterpart = EmptyClone(owner, obj);
ownerRef.SetCounterpart(counterpart);
ownerRef.MarkForReplicating(true);
IReplicationReference otherRef = other.ReferenceNewObject(counterpart, ownerRef,
GetCounterpartRef(referencingObject), fieldName);
otherRef.SetCounterpart(obj);
PutCounterpartRef(obj, otherRef);
if (_event._actionShouldStopTraversal)
{
return false;
}
return true;
}
public _IVisitor4_182(GenericReplicationSession _enclosing, IReplicationProviderInside
sourceProvider, IReplicationProviderInside targetProvider)
{
this._enclosing = _enclosing;
this.sourceProvider = sourceProvider;
this.targetProvider = targetProvider;
}
private bool PrepareObjectToBeReplicated(object obj, object referencingObject, string
fieldName)
{
//TODO Optimization: keep track of the peer we are traversing to avoid having to look in both.
Logger4Support.LogIdentity(obj);
_obj = obj;
_referencingObject = referencingObject;
_fieldName = fieldName;
IReplicationReference refA = _providerA.ProduceReference(_obj, _referencingObject
, _fieldName);
IReplicationReference refB = _providerB.ProduceReference(_obj, _referencingObject
, _fieldName);
if (refA == null && refB == null)
{
throw new Exception(string.Empty + _obj.GetType() + " " + _obj + " must be stored in one of the databases being replicated."
);
}
//FIXME: Use db4o's standard for throwing exceptions.
if (refA != null && refB != null)
{
throw new Exception(string.Empty + _obj.GetType() + " " + _obj + " cannot be referenced by both databases being replicated."
);
}
//FIXME: Use db4o's standard for throwing exceptions.
IReplicationProviderInside owner = refA == null ? _providerB : _providerA;
IReplicationReference ownerRef = refA == null ? refB : refA;
IReplicationProviderInside other = Other(owner);
IDrsUUID uuid = ownerRef.Uuid();
IReplicationReference otherRef = other.ProduceReferenceByUUID(uuid, _obj.GetType(
));
if (refA == null)
{
refA = otherRef;
}
else
{
refB = otherRef;
}
//TODO for circular referenced object, otherRef should not be null in the subsequent pass.
//But db4o always return null. A bug. check!
if (otherRef == null)
{
//Object is only present in one ReplicationProvider. Missing in the other. Could have been deleted or never replicated.
if (WasProcessed(uuid))
{
IReplicationReference otherProcessedRef = other.ProduceReferenceByUUID(uuid, _obj
.GetType());
if (otherProcessedRef != null)
{
ownerRef.SetCounterpart(otherProcessedRef.Object());
}
return(false);
}
MarkAsProcessed(uuid);
long creationTime = ownerRef.Uuid().GetLongPart();
if (creationTime > owner.TimeStamps().From())
{
//if it was created after the last time two ReplicationProviders were replicated it has to be treated as new.
if (_isReplicatingOnlyDeletions)
{
return(false);
}
return(HandleNewObject(_obj, ownerRef, owner, other, _referencingObject, _fieldName
, true, false));
}
else
{
// If it was created before the last time two ReplicationProviders were replicated it has to be treated as deleted.
// No, not always, in a three-way replication setup it can also be new.
return(HandleMissingObjectInOther(_obj, ownerRef, owner, other, _referencingObject
, _fieldName));
}
}
if (_isReplicatingOnlyDeletions)
{
return(false);
}
ownerRef.SetCounterpart(otherRef.Object());
otherRef.SetCounterpart(ownerRef.Object());
if (WasProcessed(uuid))
{
return(false);
}
//Has to be done AFTER the counterpart is set because object yet to be replicated might reference the current one, replicated previously.
MarkAsProcessed(uuid);
object objectA = refA.Object();
object objectB = refB.Object();
bool changedInA = _providerA.WasModifiedSinceLastReplication(refA);
//System.out.println("changedInA = " + changedInA);
bool changedInB = _providerB.WasModifiedSinceLastReplication(refB);
//System.out.println("changedInB = " + changedInB);
if (!changedInA && !changedInB)
{
return(false);
}
bool conflict = false;
if (changedInA && changedInB)
{
conflict = true;
}
if (changedInA && _directionTo == _providerA)
{
conflict = true;
}
if (changedInB && _directionTo == _providerB)
{
conflict = true;
}
object prevailing = _obj;
_providerA.Activate(objectA);
_providerB.Activate(objectB);
_event.ResetAction();
_event.Conflict(conflict);
_event._creationDate = TimeStampIdGenerator.IdToMilliseconds(uuid.GetLongPart());
_stateInA.SetAll(objectA, false, changedInA, TimeStampIdGenerator.IdToMilliseconds
(ownerRef.Version()));
_stateInB.SetAll(objectB, false, changedInB, TimeStampIdGenerator.IdToMilliseconds
(otherRef.Version()));
_listener.OnReplicate(_event);
if (conflict)
{
if (!_event._actionWasChosen)
{
ThrowReplicationConflictException();
}
if (_event._actionChosenState == null)
{
return(false);
}
if (_event._actionChosenState == _stateInA)
{
prevailing = objectA;
}
if (_event._actionChosenState == _stateInB)
{
prevailing = objectB;
}
}
else
{
if (_event._actionWasChosen)
{
if (_event._actionChosenState == _stateInA)
{
prevailing = objectA;
}
if (_event._actionChosenState == _stateInB)
{
prevailing = objectB;
}
if (_event._actionChosenState == null)
{
return(false);
}
}
else
{
if (changedInA)
{
prevailing = objectA;
}
if (changedInB)
{
prevailing = objectB;
}
}
}
IReplicationProviderInside prevailingPeer = prevailing == objectA ? _providerA :
_providerB;
if (_directionTo == prevailingPeer)
{
return(false);
}
if (!conflict)
{
prevailingPeer.Activate(prevailing);
}
//Already activated if there was a conflict.
if (prevailing != _obj)
{
otherRef.SetCounterpart(_obj);
otherRef.MarkForReplicating(true);
MarkAsNotProcessed(uuid);
_traverser.ExtendTraversalTo(prevailing);
}
else
{
//Now we start traversing objects on the other peer! Is that cool or what? ;)
ownerRef.MarkForReplicating(true);
}
return(!_event._actionShouldStopTraversal);
}
private void CopyStateAcross(IReplicationProviderInside sourceProvider, IReplicationProviderInside
targetProvider)
{
if (_directionTo == sourceProvider)
{
return;
}
sourceProvider.VisitCachedReferences(new _IVisitor4_182(this, sourceProvider, targetProvider
));
}
private bool HandleMissingObjectInOther(object obj, IReplicationReference ownerRef
, IReplicationProviderInside owner, IReplicationProviderInside other, object referencingObject
, string fieldName)
{
bool isConflict = false;
bool wasModified = owner.WasModifiedSinceLastReplication(ownerRef);
if (wasModified)
{
isConflict = true;
}
if (_directionTo == other)
{
isConflict = true;
}
object prevailing = null;
//by default, deletion prevails
if (isConflict)
{
owner.Activate(obj);
}
_event.ResetAction();
_event.Conflict(isConflict);
_event._creationDate = TimeStampIdGenerator.IdToMilliseconds(ownerRef.Uuid().GetLongPart
());
long modificationDate = TimeStampIdGenerator.IdToMilliseconds(ownerRef.Version());
if (owner == _providerA)
{
_stateInA.SetAll(obj, false, wasModified, modificationDate);
_stateInB.SetAll(null, false, false, ObjectStateImpl.Unknown);
}
else
{
//owner == _providerB
_stateInA.SetAll(null, false, false, ObjectStateImpl.Unknown);
_stateInB.SetAll(obj, false, wasModified, modificationDate);
}
_listener.OnReplicate(_event);
if (isConflict && !_event._actionWasChosen)
{
ThrowReplicationConflictException();
}
if (_event._actionWasChosen)
{
if (_event._actionChosenState == null)
{
return(false);
}
if (_event._actionChosenState == _stateInA)
{
prevailing = _stateInA.GetObject();
}
if (_event._actionChosenState == _stateInB)
{
prevailing = _stateInB.GetObject();
}
}
if (prevailing == null)
{
//Deletion has prevailed.
if (_directionTo == other)
{
return(false);
}
ownerRef.MarkForDeleting();
return(!_event._actionShouldStopTraversal);
}
bool needsToBeActivated = !isConflict;
//Already activated if there was a conflict.
return(HandleNewObject(obj, ownerRef, owner, other, referencingObject, fieldName,
needsToBeActivated, true));
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
if (dest == null)
{
throw new InvalidOperationException("Dest cannot be null: src=" + src + ", class="
+ claxx + ", source=" + sourceProvider.GetName() + ", target=" + targetProvider
.GetName());
}
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
public _IVisitor4_286(GenericReplicationSession _enclosing, IReplicationProviderInside
destination)
{
this._enclosing = _enclosing;
this.destination = destination;
}
private IReplicationProviderInside Other(IReplicationProviderInside peer)
{
return peer == _providerA ? _providerB : _providerA;
}
public GenericReplicationSession(IReplicationProviderInside _peerA, IReplicationProviderInside
_peerB) : this(_peerA, _peerB, new DefaultReplicationEventListener())
{
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
