public override void OnError(Exception error) { DisposeInners(); if (delayErrors) { if (!ExceptionHelper.AddException(ref errors, error)) { base.Dispose(); return; } } else { if (Interlocked.CompareExchange(ref errors, error, null) != null) { base.Dispose(); return; } } if (Interlocked.Increment(ref wip) == 1) { var ex = ExceptionHelper.Terminate(ref errors); downstream.OnError(ex); base.Dispose(); } }
internal void SubscribeAll(IEnumerable <ICompletableSource> sources) { Interlocked.Increment(ref active); try { foreach (var src in sources) { var inner = new MergeInnerObserver(this); if (!Add(inner)) { break; } Interlocked.Increment(ref active); src.Subscribe(inner); } } catch (Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } } Interlocked.Decrement(ref active); Drain(); }
void InnerError(InnerObserver sender, Exception ex) { var c = Volatile.Read(ref current); if (c == sender) { if (Interlocked.CompareExchange(ref current, null, c) == c) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); if (done && Volatile.Read(ref current) == null) { Terminate(); } } else { if (Interlocked.CompareExchange(ref errors, ex, null) == null) { Interlocked.Exchange(ref current, DISPOSED)?.Dispose(); Terminate(); } } } } }
internal override void Drain() { if (Interlocked.Increment(ref wip) == 1) { for (; ;) { if (DisposableHelper.IsDisposed(ref upstream)) { Interlocked.Exchange(ref sources, null)?.Dispose(); } else { var hasNext = false; var next = default(ICompletableSource); try { if (sources.MoveNext()) { hasNext = true; next = RequireNonNullRef(sources.Current, "The enumerator returned a null ICompletableSource"); } } catch (Exception ex) { DisposableHelper.WeakDispose(ref upstream); ExceptionHelper.AddException(ref errors, ex); ex = Volatile.Read(ref errors); downstream.OnError(ex); continue; } if (hasNext) { next.Subscribe(this); } else { DisposableHelper.WeakDispose(ref upstream); var ex = Volatile.Read(ref errors); if (ex != null) { downstream.OnError(ex); } else { downstream.OnCompleted(); } continue; } } if (Interlocked.Decrement(ref wip) == 0) { break; } } } }
internal void InnerError(Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } }
public void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref errors, error); } else { errors = error; } Next(); }
public void OnError(Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); Next(); } else { downstream.OnError(ex); } }
public void OnError(Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } Interlocked.Decrement(ref active); Drain(); }
void InnerError(Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } active = false; Drain(); }
public void InnerError(InnerSignalObserver <R> sender, Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } sender.SetDone(); Drain(); }
public void OnError(Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } Volatile.Write(ref done, true); Drain(); }
public void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref this.errors, error); } else { DisposableHelper.WeakDispose(ref upstream); downstream.OnError(error); } Drain(); }
void InnerError(InnerObserver sender, Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref errors, error); sender.SetDone(); } else { Interlocked.CompareExchange(ref errors, error, null); } Drain(); }
void InnerError(InnerObserver sender, Exception ex) { Remove(sender); if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } Interlocked.Decrement(ref active); Drain(); }
void TryEmitScalar(IDynamicValue <R> d) { var v = default(R); var success = false; try { v = d.GetValue(out success); } catch (Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { Interlocked.CompareExchange(ref errors, ex, null); } Drain(); return; } if (success) { if (Interlocked.CompareExchange(ref wip, 1, 0) == 0) { downstream.OnNext(v); if (Interlocked.Decrement(ref wip) == 0) { return; } } else { var q = scalarQueue; if (q == null) { q = new SpscLinkedArrayQueue <R>(capacityHint); Volatile.Write(ref scalarQueue, q); } q.TryOffer(v); if (Interlocked.Increment(ref wip) != 1) { return; } } DrainLoop(); } }
void SignalError(InnerObserver sender, Exception ex) { Remove(sender); if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); Interlocked.Decrement(ref active); } else { upstream.Dispose(); Interlocked.CompareExchange(ref errors, ex, null); } Drain(); }
protected override void InnerError(Exception ex, InnerObserver sender) { Remove(sender); if (delayErrors) { ExceptionHelper.AddException(ref this.errors, ex); Interlocked.Decrement(ref active); Drain(); } else { if (Interlocked.CompareExchange(ref this.errors, ex, null) == null) { Drain(); } } }
public void OnError(Exception error) { if (done) { return; } if (delayErrors) { ExceptionHelper.AddException(ref errors, error); } else { Interlocked.CompareExchange(ref errors, error, null); } done = true; Drain(); }
public void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref errors, error); Volatile.Write(ref done, true); Drain(); } else { if (Interlocked.CompareExchange(ref errors, error, null) == null) { Volatile.Write(ref done, true); Drain(); } } DisposableHelper.Dispose(ref upstream); }
public override void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref this.errors, error); if (Interlocked.Decrement(ref active) == 0) { Drain(); } } else { if (Interlocked.CompareExchange(ref this.errors, error, null) == null) { Drain(); } } }
internal void InnerError(InnerObserver sender, Exception ex) { if (delayErrors) { if (ExceptionHelper.AddException(ref error, ex)) { sender.SetDone(); Drain(); } } else { if (Interlocked.CompareExchange(ref error, ex, null) == null) { Drain(); } } }
void InnerError(Exception ex) { if (delayErrors) { if (ExceptionHelper.AddException(ref error, ex)) { Interlocked.Increment(ref done); Drain(); } } else { if (Interlocked.CompareExchange(ref error, ex, null) == null) { Drain(); } } }
void InnerError(Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref errors, ex); } else { if (Interlocked.CompareExchange(ref errors, ex, null) == null) { if (Interlocked.Increment(ref wip) == 1) { ex = ExceptionHelper.Terminate(ref errors); downstream.OnError(ex); Dispose(); } } } }
public override void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref this.errors, error); Volatile.Write(ref done, true); if (Volatile.Read(ref active) == 0) { Drain(); } } else { if (Interlocked.CompareExchange(ref this.errors, error, null) == null) { Drain(); } } }
public void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref errors, error); } else { if (Interlocked.CompareExchange(ref errors, error, null) == null) { Interlocked.Exchange(ref current, null)?.Dispose(); } } done = true; if (Volatile.Read(ref current) == null) { Terminate(); } }
void InnerError(int index, Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref error, ex); if (Interlocked.Decrement(ref ready) == 0) { Volatile.Write(ref values, null); downstream.OnError(error); } } else { DisposeAll(); if (Interlocked.Exchange(ref ready, 0) > 0) { Volatile.Write(ref values, null); downstream.OnError(ex); } } }
public void InnerError(InnerObserver <R> sender, Exception error) { sender.Dispose(); if (Volatile.Read(ref active) == sender) { if (delayErrors) { ExceptionHelper.AddException(ref errors, error); sender.SetDone(); Drain(); } else { if (Interlocked.CompareExchange(ref errors, error, null) == null) { sender.SetDone(); Drain(); } } } }
public override void OnError(Exception error) { if (done) { return; } if (delayErrors) { ExceptionHelper.AddException(ref errors, error); Volatile.Write(ref done, true); Drain(); } else { if (Interlocked.CompareExchange(ref errors, error, null) == null) { Volatile.Write(ref done, true); Drain(); } } base.Dispose(); }
void Drain() { if (Interlocked.Increment(ref wip) != 1) { return; } var missed = 1; var downstream = this.downstream; var queue = this.queue; var observers = this.observers; var n = observers.Length; var values = this.values; var hasLatest = this.hasLatest; for (; ;) { for (; ;) { if (Volatile.Read(ref disposed)) { while (queue.TryDequeue(out var _)) { ; } for (int i = 0; i < n; i++) { values[i] = default(T); } break; } if (!delayErrors) { var ex = Volatile.Read(ref error); if (ex != null) { downstream.OnError(ex); Volatile.Write(ref disposed, true); DisposeAll(); continue; } } var d = Volatile.Read(ref done) == n; var empty = !queue.TryDequeue(out var v); if (d && empty) { var ex = Volatile.Read(ref error); if (ex != null) { downstream.OnError(ex); } else { downstream.OnCompleted(); } Volatile.Write(ref disposed, true); DisposeAll(); continue; } if (empty) { break; } var idx = v.index; if (!hasLatest[idx]) { hasLatest[idx] = true; available++; } values[idx] = v.value; if (available == n) { var result = default(R); try { var a = new T[n]; Array.Copy(values, a, n); result = mapper(a); } catch (Exception ex) { if (delayErrors) { ExceptionHelper.AddException(ref error, ex); ex = ExceptionHelper.Terminate(ref error); downstream.OnError(ex); Volatile.Write(ref disposed, true); DisposeAll(); } else { if (Interlocked.CompareExchange(ref error, ex, null) == null) { downstream.OnError(ex); Volatile.Write(ref disposed, true); DisposeAll(); } } continue; } downstream.OnNext(result); } } missed = Interlocked.Add(ref wip, -missed); if (missed == 0) { break; } } }
internal override void Drain() { if (Interlocked.Increment(ref wip) == 1) { for (; ;) { var srcs = sources; var n = srcs.Length; if (DisposableHelper.IsDisposed(ref upstream)) { for (int i = index; i < n; i++) { srcs[i] = null; } } else { var i = index; if (i == n) { DisposableHelper.WeakDispose(ref upstream); var ex = Volatile.Read(ref errors); if (ex != null) { downstream.OnError(ex); } else { downstream.OnCompleted(); } } else { var src = srcs[i]; if (src == null) { DisposableHelper.WeakDispose(ref upstream); ExceptionHelper.AddException(ref errors, new NullReferenceException("The " + i + "th ICompletableSource is null")); var ex = Volatile.Read(ref errors); downstream.OnError(ex); continue; } else { srcs[i] = null; index = i + 1; src.Subscribe(this); } } } if (Interlocked.Decrement(ref wip) == 0) { break; } } } }