示例#1
0
        public Optional <ListChange <T> > Insert <T>(int index, T item, bool predicateTrue)
        {
            var toIndex = _items.Sum(index);

            _items = _items.Insert(index, predicateTrue ? 1 : 0);

            return(predicateTrue
                                ? ListChange.Insert(toIndex, item)
                                : Optional.None <ListChange <T> >());
        }
示例#2
0
 IDisposable SubscribeInner(IObservable <T> obs, IndexTrackerList <SingleAssignmentDisposable> .IndexedItem indexedItem)
 {
     return(obs.Subscribe(
                Observer.Create <T>(
                    onNext: item =>
     {
         lock (_gate)
             foreach (var currentIndex in indexedItem.Index)
             {
                 foreach (var change in _changeMapper.Replace(currentIndex, item, true))
                 {
                     _observer.OnNext(change);
                 }
             }
     },
                    onError: OnError,
                    onCompleted: () =>
     {
         lock (_gate)
         {
             foreach (var currentIndex in indexedItem.Index)
             {
                 _innerSubscriptions[currentIndex].Dispose();
                 _innerCompleted = _innerCompleted.ReplaceAt(currentIndex, true);
                 if (_outerCompleted && _innerCompleted.Sum())
                 {
                     Disposable.Combine(_innerSubscriptions).Dispose();
                     _innerSubscriptions.Clear();
                     _observer.OnCompleted();
                 }
             }
         }
     })));
 }
示例#3
0
 public void OnCompleted()
 {
     lock (_gate)
     {
         _outerCompleted = true;
         if (_innerCompleted.Sum())
         {
             Disposable.Combine(_innerSubscriptions).Dispose();
             _innerSubscriptions.Clear();
             _observer.OnCompleted();
         }
     }
 }