public void Subscribe(ICompletableObserver observer) { var srcs = sources; var n = 0; var o = new ICompletableSource[8]; try { foreach (var s in srcs) { if (n == o.Length) { var b = new ICompletableSource[n + (n >> 2)]; Array.Copy(o, 0, b, 0, n); o = b; } o[n++] = s; } } catch (Exception ex) { DisposableHelper.Error(observer, ex); return; } CompletableAmb.Subscribe(observer, o, n); }
public IDisposable Subscribe(ICompletableObserver observer) { var velocity = GetVelocity(_property).ToReactiveProperty(); var outerDisposable = new SingleAssignmentDisposable(); var currentTween = new SerialDisposable(); var observerCompletion = new RefCountDisposable(Disposable.Create(observer.OnCompleted)); outerDisposable.Disposable = new CompositeDisposable ( _target.Subscribe(x => { // Prevent observer from completing while there is a tween in progress var tweenCompletion = observerCompletion.GetDisposable(); // Dispose any previous tween in progress, if any currentTween.Disposable = new CompositeDisposable ( Tween(_property, x, _duration, velocity.Value, _easer) .SubscribeAndForget(tweenCompletion.Dispose), tweenCompletion ); }, () => observerCompletion.Dispose()), currentTween ); return(outerDisposable); }
public UsingObserver(ICompletableObserver downstream, S resource, Action <S> resourceCleanup, bool eagerCleanup) { this.downstream = downstream; this.eagerCleanup = eagerCleanup; this.resource = resource; this.resourceCleanup = resourceCleanup; }
public void Subscribe(ICompletableObserver observer) { RequireNonNull(observer, nameof(observer)); var completeSignals = new UnicastSubject <object>(); var redo = default(IObservable <U>); try { redo = RequireNonNullRef(handler(completeSignals), "The handler returned a null IObservable"); } catch (Exception ex) { DisposableHelper.Error(observer, ex); return; } var parent = new MainObserver(observer, source, new SerializedObserver <object>(completeSignals)); var d = redo.Subscribe(parent.handlerObserver); parent.handlerObserver.OnSubscribe(d); parent.HandlerNext(); }
public void Subscribe(ICompletableObserver observer) { var parent = new IgnoreAllElementsObserver(observer); observer.OnSubscribe(parent); parent.OnSubscribe(source.Subscribe(parent)); }
public void Subscribe(ICompletableObserver observer) { var bd = new BooleanDisposable(); observer.OnSubscribe(bd); if (bd.IsDisposed()) { return; } try { action(); } catch (Exception ex) { if (!bd.IsDisposed()) { observer.OnError(ex); } return; } if (!bd.IsDisposed()) { observer.OnCompleted(); } }
public void Subscribe(ICompletableObserver observer) { var o = sources; var n = o.Length; Subscribe(observer, o, n); }
public void Subscribe(ICompletableObserver observer) { var parent = new SwitchMapObserver(observer, mapper, delayErrors); observer.OnSubscribe(parent); parent.OnSubscribe(source.Subscribe(parent)); }
public void Subscribe(ICompletableObserver observer) { var parent = new DelaySubscriptionObserver(observer, source); observer.OnSubscribe(parent); other.Subscribe(parent); }
/// <summary> /// Subscribes the given completable observer to this subject /// and relays/replays the terminal events of the subject. /// </summary> /// <param name="observer">The completable observer that wants to listen to the terminal events.</param> public void Subscribe(ICompletableObserver observer) { var inner = new InnerDisposable(observer, this); observer.OnSubscribe(inner); if (Add(inner)) { if (inner.IsDisposed()) { Remove(inner); } } else { if (!inner.IsDisposed()) { var ex = Volatile.Read(ref error); if (ex == ExceptionHelper.TERMINATED) { observer.OnCompleted(); } else { observer.OnError(ex); } } } }
public IDisposable Subscribe(ICompletableObserver observer) { if (_isDisposed) { throw new ObjectDisposedException(nameof(Lapse)); } if (_subject == null) { _subject = new CompletableSubject(); } if (!_isSubscribed) { _isSubscribed = true; _action?.Invoke(this); if (_isDisposed) { observer.OnCompleted(); return(Disposable.Empty); } } return(_subject.Subscribe(observer)); }
public void Subscribe(ICompletableObserver observer) { if (maxConcurrency == int.MaxValue) { var parent = new MergeAllCoordinator(observer, delayErrors); observer.OnSubscribe(parent); parent.SubscribeAll(sources); } else { var en = default(IEnumerator <ICompletableSource>); try { en = sources.GetEnumerator(); } catch (Exception ex) { DisposableHelper.Error(observer, ex); return; } var parent = new MergeLimitedCoordinator(observer, en, delayErrors, maxConcurrency); observer.OnSubscribe(parent); parent.Drain(); } }
internal CompletableRedoWhenObserver(ICompletableObserver downstream, ICompletableSource source, IObserver <X> errorSignal) { this.downstream = downstream; this.source = source; this.terminalSignal = errorSignal; this.handlerObserver = new HandlerObserver(this); }
public FlatMapObserver(ICompletableObserver downstream, Func <T, ICompletableSource> mapper, bool delayErrors) { this.downstream = downstream; this.mapper = mapper; this.delayErrors = delayErrors; this.observers = new HashSet <IDisposable>(); }
internal static void Subscribe(ICompletableObserver observer, ICompletableSource[] sources, int n) { if (n == 0) { DisposableHelper.Complete(observer); return; } if (n == 1) { sources[0].Subscribe(observer); return; } var parent = new AmbDisposable(observer, n); observer.OnSubscribe(parent); var co = parent.observers; for (int i = 0; i < n; i++) { if (!parent.IsDisposed()) { sources[i].Subscribe(co[i]); } } }
public void Subscribe(ICompletableObserver observer) { var parent = new RepeatObserver(observer, source, predicate); observer.OnSubscribe(parent); parent.Drain(); }
public ConcatMapObserver(ICompletableObserver downstream, Func <T, ICompletableSource> mapper, bool delayErrors) { this.downstream = downstream; this.mapper = mapper; this.delayErrors = delayErrors; this.inner = new InnerObserver(this); this.queue = new ConcurrentQueue <T>(); }
public void Subscribe(ICompletableObserver observer) { var sad = new SingleAssignmentDisposable(); observer.OnSubscribe(sad); sad.Disposable = scheduler.Schedule(observer, time, COMPLETE); }
public void Subscribe(ICompletableObserver observer) { var parent = new TaskDisposable(observer); observer.OnSubscribe(parent); task.ContinueWith(TASK, parent); }
public void Subscribe(ICompletableObserver observer) { var parent = new CompletableFlatMapSingleObserver <T>(observer, mapper); observer.OnSubscribe(parent); source.Subscribe(parent); }
public void Subscribe(ICompletableObserver observer) { var parent = new TimeoutObserver(observer, fallback); observer.OnSubscribe(parent); parent.SetTask(scheduler.Schedule(parent, timeout, RUN)); source.Subscribe(parent); }
public void Subscribe(ICompletableObserver observer) { var parent = new DelaySubscriptionObserver(observer, source); observer.OnSubscribe(parent); parent.SetTask(scheduler.Schedule(parent, delay, RUN)); }
public void Subscribe(ICompletableObserver observer) { var parent = new TakeUntilObserver(observer); observer.OnSubscribe(parent); other.Subscribe(parent.other); source.Subscribe(parent); }
public void OnError(Exception error) { var d = downstream; downstream = null; upstream = null; d?.OnError(error); }
public void OnCompleted() { var d = downstream; downstream = null; upstream = null; d?.OnCompleted(); }
public void Subscribe(ICompletableObserver observer) { var parent = new SubscribeOnObserver(observer, source); observer.OnSubscribe(parent); var d = scheduler.Schedule(parent, RUN); parent.SetTask(d); }
internal AmbDisposable(ICompletableObserver downstream, int n) { this.downstream = downstream; var o = new AmbObserver[n]; for (int i = 0; i < n; i++) { o[i] = new AmbObserver(this, i); } observers = o; Volatile.Write(ref index, -1); }
public void Subscribe(ICompletableObserver observer) { var resource = default(S); try { resource = resourceSupplier(); } catch (Exception ex) { DisposableHelper.Error(observer, ex); return; } var c = default(ICompletableSource); try { c = RequireNonNullRef(sourceSelector(resource), "The sourceSelector returned an null ICompletableSource"); } catch (Exception ex) { if (eagerCleanup) { try { resourceCleanup(resource); } catch (Exception exc) { ex = new AggregateException(ex, exc); } DisposableHelper.Error(observer, ex); } else { DisposableHelper.Error(observer, ex); try { resourceCleanup(resource); } catch (Exception) { // TODO where could this go??? } } return; } c.Subscribe(new UsingObserver(observer, resource, resourceCleanup, eagerCleanup)); }
public IDisposable Subscribe(ICompletableObserver observer) { if (!_isStarted) { _subscriptionLapse = Lapse.Create(); _isStarted = true; StartNext(); } return(new CompositeDisposable( Disposable.Create(Complete), _subscriptionLapse.Subscribe(observer))); }
public void Subscribe(ICompletableObserver observer) { var parent = new CreateDisposableEmitter(observer); observer.OnSubscribe(parent); try { onSubscribe(parent); } catch (Exception ex) { parent.OnError(ex); } }