public ObservableCursorSubscription(ObservableCursor <T> cursor, int index, int take, IObserver <T> observer)
{
Contract.Requires(cursor != null);
Contract.Requires(index >= 0);
Contract.Requires(take == subscribeUnlimited || take > 0);
Contract.Requires(observer != null);
this.cursor = cursor;
this.index = index;
this.take = take;
this.observer = observer;
Contract.Assume(cursor.subscriptions != null);
cursor.subscriptions.Add(this);
}
public ObservableCursorBranch(ObservableCursor <T> cursor, int currentIndex, CompositeDisposable parentDisposables)
{
Contract.Requires(cursor != null);
Contract.Requires(cursor.branches != null);
Contract.Requires(cursor.elements != null);
Contract.Requires(cursor.latestIndex >= -1);
Contract.Requires(currentIndex >= 0);
Contract.Requires(currentIndex >= cursor.firstElementIndex);
Contract.Requires(currentIndex > cursor.latestIndex || cursor.elements.Count >= cursor.latestIndex - currentIndex);
Contract.Requires(!cursor.stopped || currentIndex <= cursor.latestIndex + 1);
Contract.Requires(parentDisposables != null);
Contract.Ensures(this.cursor == cursor);
Contract.Ensures(this.currentIndex == currentIndex);
Contract.Ensures(!IsSynchronized);
Contract.Ensures(IsForwardOnly == cursor.IsForwardOnly);
Contract.Ensures(IsSequenceTerminated == cursor.IsSequenceTerminated);
Contract.Ensures(LatestIndex == cursor.latestIndex);
Contract.Ensures(CurrentIndex == currentIndex);
Contract.Ensures(AtEndOfSequence == (cursor.IsSequenceTerminated && currentIndex == cursor.latestIndex + 1));
this.cursor = cursor;
this.currentIndex = currentIndex;
parentDisposables.Add(this);
cursor.branches.Add(this);
bool removed = false;
var subscription = Disposable.Create(() =>
{
if (!removed)
{
// Set this variable first in case of reentry.
removed = true;
parentDisposables.Remove(this);
cursor.branches.Remove(this);
}
});
disposables.Add(subscription);
Contract.Assert(currentIndex > cursor.latestIndex || cursor.elements.Count >= cursor.latestIndex - currentIndex);
}
