public static ILiveList<int> Range(ILiveValue<int> startValue, ILiveValue<int> countValue) { LiveObserver<IValueState<int>> startObserver = null; LiveObserver<IValueState<int>> countObserver = null; return LiveListObservable<int>.Create( innerChanged => { countValue.Subscribe(countObserver = countValue.CreateObserver(innerChanged)); startValue.Subscribe(startObserver = startValue.CreateObserver(innerChanged)); return Lockers.Empty; }, (innerChanged, notified, stateLock, oldState) => { // get state var count = countObserver.GetState(); var start = startObserver.GetState(); var newStatus = count.Status.And(start.Status); // work out delta ListDelta<int> delta = null; if (newStatus.IsDeltaRelevant() && (count.HasChange || start.HasChange)) { delta = new ListDelta<int>(); // adjust head var head = Math.Min(Math.Max(start.OldValue - start.NewValue, -count.OldValue), count.NewValue); if (head < 0) delta.Delete(0, Enumerable.Range(start.OldValue, -head)); else if (head > 0) delta.Insert(0, Enumerable.Range(start.NewValue, head)); var currentCount = count.OldValue + head; var leftoverCount = count.OldValue + Math.Min(0, head); // adjust tail var tail = count.NewValue - currentCount; if (tail > 0) delta.Insert(currentCount, Enumerable.Range(start.NewValue + currentCount, tail)); else if (tail < 0) delta.Delete(count.NewValue, Enumerable.Range(start.OldValue + count.OldValue + tail, -tail)); } // work out new state var result = new CollectionState<int, IListDelta<int>, IList<int>>(); result.SetState( oldState.GetStatus().Add(newStatus), delta, Enumerable.Range(start.NewValue, count.NewValue), Math.Max(count.LastUpdated, start.LastUpdated), stateLock); return result; }, () => { startObserver.Dispose(); countObserver.Dispose(); }); }
public void TestListDeltaSimple() { // single delete { var d = new ListDelta<int>(); d.Delete(3, new[] { 1 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 3, DenseIndex = 0, Data = new ListIndexDelta<int> { DeleteItems = new[] { 1 }, }, }, }, new IndexNodeComparer<int>())); } // subsequent deletes { var d = new ListDelta<int>(); d.Delete(3, new[] { 1 }); d.Delete(3, new[] { 2 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 3, DenseIndex = 0, Data = new ListIndexDelta<int> { DeleteItems = new[] { 1, 2 }, }, }, }, new IndexNodeComparer<int>())); } // subsequent deletes { var d = new ListDelta<int>(); d.Delete(1, new[] { 1 }); d.Delete(0, new[] { 0 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 0, DenseIndex = 0, Data = new ListIndexDelta<int> { DeleteItems = new[] { 0, 1 }, }, }, }, new IndexNodeComparer<int>())); } // single insert { var d = new ListDelta<int>(); d.Insert(3, new[] { 1 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 3, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 1 }, }, }, }, new IndexNodeComparer<int>())); } // subsequent inserts { var d = new ListDelta<int>(); d.Insert(3, new[] { 1 }); d.Insert(3, new[] { 2 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 3, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 2, 1 }, }, }, }, new IndexNodeComparer<int>())); } // insert and delete complementing (update) { var d = new ListDelta<int>(); d.Delete(3, new[] { 1 }); d.Insert(3, new[] { 2 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 3, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 2 }, DeleteItems = new[] { 1 }, }, }, }, new IndexNodeComparer<int>())); } // multiple updates { var d = new ListDelta<int>(); d.Update(3, 1, 2); d.Update(3, 2, 3); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 3, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 3 }, DeleteItems = new[] { 1 }, }, }, }, new IndexNodeComparer<int>())); } // insert and delete offsetting { var d = new ListDelta<int>(); d.Insert(3, new[] { 1 }); d.Delete(3, new[] { 1 }); Assert.IsTrue(!d.IndexDeltas.Any()); } // interleaved offsetting delete/inserts { var d = new ListDelta<int>(); d.Delete(0, new[] { 1, 2, 3, 4, 5, 7 }); d.Insert(0, new[] { 1, 2, 4, 5, 6, 7 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 2, DenseIndex = 0, Data = new ListIndexDelta<int> { DeleteItems = new[] { 3 }, }, }, new IndexNode<int> { Index = 4, DenseIndex = 1, Data = new ListIndexDelta<int> { InsertItems = new[] { 6 }, }, } }, new IndexNodeComparer<int>())); } }
public void TestListDeltaCanonical() { { var d = new ListDelta<int>(); d.Insert(0, new[] { 100 }); d.Insert(1, new[] { 101 }); d.Delete(2, new[] { 0, 1 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 0, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 100, 101 }, DeleteItems = new[] { 0, 1 }, }, }, }, new IndexNodeComparer<int>())); } { var d = new ListDelta<int>(); d.Delete(0, new[] { 0, 1 }); d.Insert(0, new[] { 100 }); d.Insert(1, new[] { 101 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 0, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 100, 101 }, DeleteItems = new[] { 0, 1 }, }, }, }, new IndexNodeComparer<int>())); } { var d = new ListDelta<int>(); d.Delete(0, new[] { 100 }); d.Delete(2, new[] { 102 }); d.Delete(1, new[] { 101 }); var indexDeltas = d.IndexDeltas.ToArray(); Assert.IsTrue(indexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 0, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new int[] { }, DeleteItems = new[] { 100 }, }, }, new IndexNode<int> { Index = 1, DenseIndex = 1, Data = new ListIndexDelta<int> { InsertItems = new int[] { }, DeleteItems = new[] { 101, 102 }, }, }, }, new IndexNodeComparer<int>())); } // case where the root node gets canonicalized away { var d = new ListDelta<int>(); d.Update(4, 4, 104); d.Update(6, 6, 106); d.Update(2, 2, 102); d.Update(8, 8, 108); d.Update(3, 3, 103); // <== root changed from 104 to 106 var indexDeltas = d.IndexDeltas.ToArray(); Assert.IsTrue(indexDeltas.SequenceEqual(new[] { new IndexNode<int> { Index = 2, DenseIndex = 0, Data = new ListIndexDelta<int> { InsertItems = new[] { 102, 103, 104 }, DeleteItems = new[] { 2, 3, 4 }, }, }, new IndexNode<int> { Index = 6, DenseIndex = 1, Data = new ListIndexDelta<int> { InsertItems = new[] { 106 }, DeleteItems = new[] { 6 }, }, }, new IndexNode<int> { Index = 8, DenseIndex = 2, Data = new ListIndexDelta<int> { InsertItems = new[] { 108 }, DeleteItems = new[] { 8 }, }, }, }, new IndexNodeComparer<int>())); } }
public void TestListDeltaEmpty() { { var d = new ListDelta<int>(); d.Insert(0, new[] { 1 }); d.Delete(0, new[] { 1 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual( new IndexNode<int>[0], new IndexNodeComparer<int>())); } { var d = new ListDelta<int>(); d.Delete(0, new[] { 1 }); d.Insert(0, new[] { 1 }); Assert.IsTrue(d.IndexDeltas.SequenceEqual( new IndexNode<int>[0], new IndexNodeComparer<int>())); } }