public static ITrackingItem CreateTrackingItem(Key key, TrackingItemState state)
{
var tuple = Tuple.Create(typeof(string));
var diff = new DifferentialTuple(tuple);
return((ITrackingItem)Activator.CreateInstance(TrackingItemType, key, state, diff));
}
public void RegisterRevivedItemWithDifferenceTupleTest()
{
using (var session = Domain.OpenSession())
using (var tx = session.OpenTransaction()) {
var registry = session.EntityChangeRegistry;
Assert.That(registry.Count, Is.EqualTo(0));
Assert.That(registry.GetItems(PersistenceState.New).Any(), Is.False);
Assert.That(registry.GetItems(PersistenceState.Modified).Any(), Is.False);
Assert.That(registry.GetItems(PersistenceState.Removed).Any(), Is.False);
var dTuple = new DifferentialTuple(
Tuple.Create <int, string>(0, null),
Tuple.Create <int, string>(0, "here is some changes"));
var state1 = CreateDummyState(session, 100, dTuple);
state1.SetPersistenceState(PersistenceState.Removed);
registry.Register(state1);
Assert.That(registry.GetItems(PersistenceState.New).Any(), Is.False);
Assert.That(registry.GetItems(PersistenceState.Modified).Any(), Is.False);
Assert.That(registry.GetItems(PersistenceState.Removed).Count(), Is.EqualTo(1));
Assert.That(registry.GetItems(PersistenceState.Removed).All(i => i == state1));
Assert.That(registry.Count, Is.EqualTo(1));
state1.SetPersistenceState(PersistenceState.New);
registry.Register(state1);
Assert.That(state1.PersistenceState, Is.EqualTo(PersistenceState.Modified));
Assert.That(registry.GetItems(PersistenceState.New).Any(), Is.False);
Assert.That(registry.GetItems(PersistenceState.Modified).Count(), Is.EqualTo(1));
Assert.That(registry.GetItems(PersistenceState.Modified).All(i => i == state1), Is.True);
Assert.That(registry.GetItems(PersistenceState.Removed).Any(), Is.False);
Assert.That(registry.Count, Is.EqualTo(1));
}
}
internal void RemapKey(Key newKey)
{
key = newKey;
if (IsActual)
{
var tuple = Tuple;
if (tuple == null)
{
return;
}
var dTuple = tuple as DifferentialTuple;
if (dTuple != null)
{
tuple = dTuple.Origin;
}
tuple = Type.InjectPrimaryKey(tuple, key.Value);
if (dTuple != null)
{
Tuple = new DifferentialTuple(tuple, dTuple.Difference);
}
else
{
Tuple = tuple;
}
}
}
public TrackingItem(Key key, TrackingItemState state, DifferentialTuple tuple)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (state != TrackingItemState.Deleted && tuple == null)
{
throw new ArgumentNullException("tuple");
}
Key = key;
if (tuple != null)
{
RawData = (DifferentialTuple)tuple.Clone();
}
State = state;
}
public void DifferentialTest()
{
TupleDescriptor descriptor = TupleDescriptor.Create(fieldTypes);
Xtensive.Tuples.Tuple t1 = Tuple.Create(descriptor);
Xtensive.Tuples.Tuple t2 = t1.Clone();
PopulateData(fieldTypes, t2, t1);
DifferentialTuple d = new DifferentialTuple(t1);
AssertAreSame(t1, d);
PopulateData(fieldTypes, t1, d);
AssertAreSame(t1, d);
DifferentialTuple c = (DifferentialTuple)d.Clone();
AssertAreSame(d, c);
d.Reset();
AssertAreSame(t2, d);
AssertAreSame(t1, c.ToRegular());
}
public void DifferentialTupleSerializationTest()
{
var origin = Tuple.Create(1, 2);
var dt1 = new DifferentialTuple(origin);
dt1.SetValue(1, 3);
var dt2 = new DifferentialTuple(origin);
dt1.SetValue(1, 4);
var all = new[] { dt1, dt2 };
var clone = Cloner.Clone(all);
AssertEx.HasSameElements(all, clone);
var dt1Clone = clone[0];
var dt2Clone = clone[1];
var originClone = dt1Clone.Origin;
Assert.AreSame(originClone, dt2Clone.Origin);
originClone.SetValue(0, 2);
Assert.AreEqual(2, dt1Clone.GetValue(0));
Assert.AreEqual(2, dt2Clone.GetValue(0));
}
