public void OnCompleted() { if (eagerCleanup) { var a = Interlocked.Exchange(ref resourceCleanup, null); if (a != null) { var r = resource; resource = default(S); try { a(r); } catch (Exception ex) { downstream.OnError(ex); return; } } downstream.OnCompleted(); } else { downstream.OnCompleted(); CleanupAfter(); } }
public void OnError(Exception error) { if (Interlocked.CompareExchange(ref exclude, 1, 0) == 0) { DisposableHelper.Dispose(ref task); downstream.OnError(error); } }
public void OnError(Exception error) { if (Volatile.Read(ref disposed) == 0) { downstream.OnError(error); } }
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(); } }
/// <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 void OnError(Exception error) { var d = Interlocked.Exchange(ref resource, DisposableHelper.DISPOSED); if (d != DisposableHelper.DISPOSED) { downstream.OnError(error); d?.Dispose(); } }
public void OnError(Exception error) { try { downstream.OnError(error); } catch (Exception) { // TODO what should happen with these? } }
public void OnError(Exception error) { if (delayErrors) { ExceptionHelper.AddException(ref this.errors, error); } else { DisposableHelper.WeakDispose(ref upstream); downstream.OnError(error); } Drain(); }
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); } } return; } var src = Volatile.Read(ref source); if (src != null) { src = Interlocked.Exchange(ref source, null); if (src != null) { var a = cancel; cancel = null; a?.Invoke(this); src.Subscribe(this); } } }
public void OnError(Exception error) { var fb = default(ICompletableSource); try { fb = RequireNonNullRef(handler(error), "The handler returned a null ICompletableSource"); } catch (Exception ex) { downstream.OnError(new AggregateException(error, ex)); return; } var inner = new CompletableInnerObserver(downstream); if (Interlocked.CompareExchange(ref fallbackObserver, inner, null) == null) { fb.Subscribe(inner); } }
void Error(Exception error, bool callTerminate) { upstream = DisposableHelper.DISPOSED; try { onError?.Invoke(error); } catch (Exception ex) { error = new AggregateException(error, ex); } if (callTerminate) { try { onTerminate?.Invoke(); } catch (Exception ex) { error = new AggregateException(error, ex); } } downstream.OnError(error); try { onAfterTerminate?.Invoke(); } catch (Exception) { // FIXME what should happen with the exception } Finally(); }
internal void Run() { if (CurrentCount != 0) { try { Wait(); } catch (ObjectDisposedException) { return; } } var ex = error; if (ex != ExceptionHelper.TERMINATED) { downstream.OnError(ex); } else { downstream.OnCompleted(); } }
internal void Run() { for (; ;) { var d = Volatile.Read(ref task); if (d == DisposableHelper.DISPOSED) { break; } if (Interlocked.CompareExchange(ref task, DisposableHelper.EMPTY, d) == d) { var ex = error; if (ex != null) { downstream.OnError(ex); } else { downstream.OnCompleted(); } break; } } }
public virtual void OnError(Exception error) { downstream.OnError(error); }
internal static void Error(this ICompletableObserver observer, Exception error) { observer.OnSubscribe(EMPTY); observer.OnError(error); }
public void OnError(Exception error) { DisposableHelper.WeakDispose(ref upstream); downstream.OnError(error); }
public void OnError(Exception error) { other = null; downstream.OnError(error); }
public void OnError(Exception error) { next = null; downstream.OnError(error); }