protected override void DrainOutput() { var a = actual; int missed = 1; for (;;) { bool d = Volatile.Read(ref done); bool empty; try { empty = queue.IsEmpty(); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); s.Cancel(); ExceptionHelper.AddError(ref error, ex); ex = ExceptionHelper.Terminate(ref error); a.OnError(ex); worker.Dispose(); return; } if (!empty) { a.TryOnNext(default(T)); } if (d) { Exception ex = Volatile.Read(ref error); if (ex != null) { a.OnError(ex); } else { a.OnComplete(); } worker.Dispose(); return; } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
public bool IsValid() { if (this.Name.Length > 255) { ExceptionHelper.AddError("FeatureName:", "Should less than 255 characters!"); return(false); } return(true); }
public override void OnError(Exception e) { if (ExceptionHelper.AddError(ref error, e)) { Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
internal void otherError(Exception e) { if (ExceptionHelper.AddError(ref error, e)) { Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
public void InnerError(CombineLatestSubscriber sender, Exception e) { if (ExceptionHelper.AddError(ref error, e)) { InnerComplete(sender); } else { ExceptionHelper.OnErrorDropped(e); } }
internal void CloseError(Exception e) { open.Cancel(); if (ExceptionHelper.AddError(ref error, e)) { Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
public void OnError(Exception e) { if (ExceptionHelper.AddError(ref error, e)) { Volatile.Write(ref done, true); Schedule(); } else { ExceptionHelper.OnErrorDropped(e); } }
public override void OnError(Exception e) { if (ExceptionHelper.AddError(ref error, e)) { Volatile.Write(ref done, true); Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
public void OnError(Exception e) { other.Cancel(); if (ExceptionHelper.AddError(ref error, e)) { Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
public override void InnerError(Exception e) { if (ExceptionHelper.AddError(ref error, e)) { Volatile.Write(ref active, false); Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
internal void InnerError(Exception ex) { if (ExceptionHelper.AddError(ref error, ex)) { CancelAll(); Drain(); } else { ExceptionHelper.OnErrorDropped(ex); } }
internal void InnerError(Exception ex) { if (ExceptionHelper.AddError(ref error, ex)) { Cancel(); ex = ExceptionHelper.Terminate(ref error); actual.OnError(ex); } else { ExceptionHelper.OnErrorDropped(ex); } }
public virtual bool IsValid() { if (this.CreateBy == null) { ExceptionHelper.AddError("CreateBy", "Should not have null value!"); } if (this.CreateDate == null || this.CreateDate == DateTime.MinValue) { this.CreateDate = DateTime.Now; } return(true); }
internal void InnerError(long index, SwitchMapInnerSubscriber inner, Exception ex) { if (Volatile.Read(ref this.index) == index) { if (ExceptionHelper.AddError(ref error, ex)) { s.Cancel(); inner.SetDone(); Drain(); return; } } ExceptionHelper.OnErrorDropped(ex); }
internal void InnerError(FlatMapInnerSubscriber sender, Exception ex) { if (ExceptionHelper.AddError(ref error, ex)) { if (!delayErrors) { CancelAll(); } sender.svDone(); Drain(); } else { ExceptionHelper.OnErrorDropped(ex); } }
public void OnNext(T t) { if (done) { return; } long idx = Interlocked.Increment(ref index); var current = Volatile.Read(ref inner); current?.Cancel(); IPublisher <R> p; try { p = mapper(t); if (p == null) { throw new NullReferenceException("The mapper returned a null IPublisher"); } } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); s.Cancel(); if (ExceptionHelper.AddError(ref error, ex)) { Volatile.Write(ref done, true); Drain(); } else { Volatile.Write(ref done, true); ExceptionHelper.OnErrorDropped(ex); } return; } var inr = new SwitchMapInnerSubscriber(this, prefetch, idx); if (Interlocked.CompareExchange(ref inner, inr, current) == current) { p.Subscribe(inr); } }
public override void InnerError(Exception e) { if (ExceptionHelper.AddError(ref error, e)) { s.Cancel(); if (Interlocked.Increment(ref serializer) == 1) { e = ExceptionHelper.Terminate(ref error); actual.OnError(e); } } else { ExceptionHelper.OnErrorDropped(e); } }
public void InnerError(ZipInnerSubscriber inner, Exception ex) { if (ExceptionHelper.AddError(ref error, ex)) { inner.SetDone(); if (!delayErrors) { CancelAll(); } Drain(); } else { ExceptionHelper.OnErrorDropped(ex); } }
internal void InnerError(Exception ex) { if (ExceptionHelper.AddError(ref error, ex)) { ex = ExceptionHelper.Terminate(ref error); if (!ExceptionHelper.IsTerminated(ex)) { actual.OnError(ex); if (QueueDrainHelper.Enter(ref wip)) { Clear(); } } } else { ExceptionHelper.OnErrorDropped(ex); } }
public void OnError(Exception e) { if (lvDone()) { ExceptionHelper.OnErrorDropped(e); } else if (ExceptionHelper.AddError(ref error, e)) { if (!delayErrors) { CancelAll(); } Volatile.Write(ref done, true); Drain(); } else { ExceptionHelper.OnErrorDropped(e); } }
internal void OnError <T>(ISubscriber <T> actual, Exception e) { if (Volatile.Read(ref wip) == 0 && Interlocked.CompareExchange(ref wip, 1, 0) == 0) { actual.OnError(e); } else { if (ExceptionHelper.AddError(ref this.error, e)) { if (Interlocked.Increment(ref wip) == 1) { e = ExceptionHelper.Terminate(ref this.error); actual.OnError(e); } } else { ExceptionHelper.OnErrorDropped(e); } } }
void Drain() { if (!QueueDrainHelper.Enter(ref wip)) { return; } int missed = 1; var a = actual; var q = queue; var bs = buffers; for (;;) { for (;;) { if (Volatile.Read(ref cancelled)) { foreach (var close in buffers) { close.Cancel(); } buffers.Clear(); queue.Clear(); return; } if (HandleException(a, q)) { return; } BufferWork bw; if (q.Poll(out bw)) { switch (bw.type) { case BufferWorkType.COMPLETE: { var c = Interlocked.Exchange(ref this.s, SubscriptionHelper.Cancelled); if (c == null) { q.Clear(); a.OnSubscribe(EmptySubscription <IList <T> > .Instance); } else { c.Cancel(); q.Clear(); } long p = produced; if (p != 0L) { BackpressureHelper.Produced(ref requested, produced); } BackpressureHelper.PostComplete(ref requested, actual, this, ref cancelled); return; } case BufferWorkType.OPEN: { var b = bw.buffer; bs.AddLast(b); IPublisher <V> p; try { p = close(b.u); if (p == null) { throw new NullReferenceException("The close function returned a null IPublisher"); } } catch (Exception exc) { ExceptionHelper.ThrowIfFatal(exc); ExceptionHelper.AddError(ref error, exc); HandleException(a, q); return; } p.Subscribe(b); } break; case BufferWorkType.CLOSE: { if (bs.Remove(bw.buffer)) { var b = bw.buffer.buffer; if (b.Count != 0) { produced++; a.OnNext(b); } else { Request(1); } } } break; default: { foreach (var buffer in bs) { buffer.buffer.Add(bw.value); } } break; } } else { break; } } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
void Drain() { if (!QueueDrainHelper.Enter(ref wip)) { return; } int missed = 1; var a = actual; var q = queue; var en = enumerator; for (;;) { if (en == null) { if (Volatile.Read(ref cancelled)) { q.Clear(); en?.Dispose(); enumerator = null; return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); q.Clear(); en?.Dispose(); enumerator = null; a.OnError(ex); return; } bool d = Volatile.Read(ref done); T v; if (queue.Poll(out v)) { en = mapper(v).GetEnumerator(); enumerator = en; } else { if (d) { en?.Dispose(); enumerator = null; a.OnComplete(); return; } } } if (en != null) { long r = Volatile.Read(ref requested); long e = 0L; while (e != r) { if (Volatile.Read(ref cancelled)) { q.Clear(); en?.Dispose(); enumerator = null; return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); q.Clear(); en?.Dispose(); enumerator = null; a.OnError(ex); return; } bool b = hasValue; if (!b) { try { b = en.MoveNext(); } catch (Exception exc) { ExceptionHelper.ThrowIfFatal(exc); s.Cancel(); q.Clear(); ExceptionHelper.AddError(ref error, exc); exc = ExceptionHelper.Terminate(ref error); a.OnError(exc); return; } hasValue = b; } if (b) { a.OnNext(en.Current); e++; hasValue = false; } else { en?.Dispose(); en = null; enumerator = en; break; } } if (e == r) { if (Volatile.Read(ref cancelled)) { q.Clear(); en?.Dispose(); enumerator = null; return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); q.Clear(); en?.Dispose(); enumerator = null; a.OnError(ex); return; } bool b = hasValue; if (!b) { try { b = en.MoveNext(); } catch (Exception exc) { ExceptionHelper.ThrowIfFatal(exc); s.Cancel(); q.Clear(); ExceptionHelper.AddError(ref error, exc); exc = ExceptionHelper.Terminate(ref error); a.OnError(exc); return; } hasValue = b; } if (!b) { en?.Dispose(); en = null; enumerator = en; } } if (e != 0 && r != long.MaxValue) { Interlocked.Add(ref requested, -e); } if (en == null) { continue; } } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
public override void Drain() { if (!QueueDrainHelper.Enter(ref wip)) { return; } for (;;) { if (Volatile.Read(ref cancelled)) { queue.Clear(); return; } if (!Volatile.Read(ref active)) { bool d = Volatile.Read(ref done); T t; bool empty; try { empty = !queue.Poll(out t); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); s.Cancel(); queue.Clear(); ExceptionHelper.AddError(ref error, ex); ex = ExceptionHelper.Terminate(ref error); actual.OnError(ex); return; } if (d && empty) { actual.OnComplete(); return; } if (!empty) { if (fusionMode != FuseableHelper.SYNC) { int c = consumed + 1; if (c == limit) { consumed = 0; s.Request(c); } else { consumed = c; } } IPublisher <R> p; try { p = mapper(t); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); s.Cancel(); queue.Clear(); ExceptionHelper.AddError(ref error, ex); ex = ExceptionHelper.Terminate(ref error); actual.OnError(ex); return; } if (p == null) { s.Cancel(); queue.Clear(); ExceptionHelper.AddError(ref error, new NullReferenceException("The mapper returned a null IPublisher.")); var ex = ExceptionHelper.Terminate(ref error); actual.OnError(ex); return; } Volatile.Write(ref active, true); p.Subscribe(inner); } } if (Interlocked.Decrement(ref wip) == 0) { break; } } }
protected override void DrainAsyncNoDelay() { var a = actual; var q = queue; long e = emitted; long p = polled; int lim = limit; int missed = 1; for (;;) { long r = Volatile.Read(ref requested); while (e != r) { if (Volatile.Read(ref cancelled)) { q.Clear(); return; } bool d = Volatile.Read(ref done); if (d) { Exception ex = error; if (ex != null) { q.Clear(); a.OnError(ex); worker.Dispose(); return; } } T v; bool empty; try { empty = !q.Poll(out v); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); s.Cancel(); q.Clear(); ExceptionHelper.AddError(ref error, ex); ex = ExceptionHelper.Terminate(ref error); a.OnError(ex); worker.Dispose(); return; } if (d && empty) { a.OnComplete(); worker.Dispose(); return; } if (empty) { break; } if (a.TryOnNext(v)) { e++; } if (++p == lim) { p = 0L; s.Request(lim); } } if (e == r) { if (Volatile.Read(ref cancelled)) { q.Clear(); return; } bool d = Volatile.Read(ref done); if (d) { Exception ex = error; if (ex != null) { q.Clear(); a.OnError(ex); worker.Dispose(); return; } if (q.IsEmpty()) { a.OnComplete(); worker.Dispose(); return; } } } emitted = e; polled = p; missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
void DrainLoop() { int missed = 1; var a = actual; var array = subscribers; int n = array.Length; for (;;) { long r = Volatile.Read(ref requested); long e = 0L; while (e != r) { if (Volatile.Read(ref cancelled)) { Cleanup(); return; } var ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); Cleanup(); a.OnError(ex); return; } bool d = Volatile.Read(ref done) == 0; bool empty = true; bool full = false; foreach (var inner in array) { var q = Volatile.Read(ref inner.queue); if (q != null) { T v; bool hasValue; try { hasValue = q.Poll(out v); } catch (Exception exc) { ExceptionHelper.AddError(ref error, exc); ex = ExceptionHelper.Terminate(ref error); CancelAll(); Cleanup(); a.OnError(ex); return; } if (hasValue) { empty = false; a.OnNext(v); inner.RequestOne(); if (++e == r) { full = true; break; } } } } if (full) { break; } if (d && empty) { a.OnComplete(); return; } if (empty) { break; } } if (e == r) { if (Volatile.Read(ref cancelled)) { Cleanup(); return; } var ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); Cleanup(); a.OnError(ex); return; } bool d = Volatile.Read(ref done) == 0; bool empty = true; foreach (var inner in array) { var q = Volatile.Read(ref inner.queue); if (q != null && !q.IsEmpty()) { empty = false; break; } } if (d && empty) { a.OnComplete(); return; } } if (e != 0L && r != long.MaxValue) { Interlocked.Add(ref requested, -e); } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
void DrainLoop() { int missed = 1; var a = actual; for (;;) { long r = Volatile.Read(ref requested); long m = 0; long e = 0; bool d; var sq = Volatile.Read(ref scalarQueue); if (sq != null) { while (e != r) { if (CheckCancelOrError(a)) { return; } R v; if (sq.Poll(out v)) { a.OnNext(v); e++; } else { break; } } } var inners = tracker.Values(); int n = inners.Length; for (int i = 0; i < n; i++) { if (CheckCancelOrError(a)) { return; } var inner = Volatile.Read(ref inners[i]); if (inner != null) { d = inner.lvDone(); IQueue <R> q = inner.GetQueue(); if (q == null || q.IsEmpty()) { if (d) { m++; tracker.Remove(i); } } else { while (e != r) { if (CheckCancelOrError(a)) { return; } d = inner.lvDone(); R v; bool hasValue; try { hasValue = q.Poll(out v); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); inner.Cancel(); ExceptionHelper.AddError(ref error, ex); if (CheckCancelOrError(a)) { return; } d = true; hasValue = false; v = default(R); } if (hasValue) { a.OnNext(v); e++; inner.RequestOne(); } else { if (d) { m++; tracker.Remove(i); } break; } } if (e == r) { if (CheckCancelOrError(a)) { return; } if (inner.lvDone() && q.IsEmpty()) { m++; tracker.Remove(i); } } } } } if (CheckCancelOrError(a)) { return; } d = lvDone(); n = tracker.Size(); sq = Volatile.Read(ref scalarQueue); if (d && n == 0 && (sq == null || sq.IsEmpty())) { Exception ex = lvError(); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); a.OnError(ex); } else { a.OnComplete(); } return; } if (e != 0 && r != long.MaxValue) { Interlocked.Add(ref requested, -e); } if (m != 0 && !lvDone() && !lvCancelled()) { s.Request(m); } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
void DrainNoDelay() { var a = actual; var c = latest; int n = c.Length; var q = queue; int missed = 1; for (;;) { if (Volatile.Read(ref cancelled)) { Cleanup(); return; } if (Volatile.Read(ref hasEmptySource)) { Exception ex = ExceptionHelper.Terminate(ref error); Cleanup(); if (ex != null) { a.OnError(ex); } else { a.OnComplete(); } return; } long r = Volatile.Read(ref requested); long e = 0L; while (e != r) { if (Volatile.Read(ref cancelled)) { Cleanup(); return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); Cleanup(); a.OnError(ex); return; } bool d = Volatile.Read(ref complete) == n; Entry v; bool empty = !q.Poll(out v); if (d && empty) { Cleanup(); a.OnComplete(); return; } R result; try { result = combiner(v.row); } catch (Exception exc) { ExceptionHelper.ThrowIfFatal(exc); CancelAll(); Cleanup(); ExceptionHelper.AddError(ref error, exc); exc = ExceptionHelper.Terminate(ref error); a.OnError(exc); return; } if (a.TryOnNext(result)) { e++; } v.sender.RequestOne(); } if (e == r) { if (Volatile.Read(ref cancelled)) { Cleanup(); return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); Cleanup(); a.OnError(ex); return; } if (Volatile.Read(ref complete) == n && q.IsEmpty()) { Cleanup(); a.OnComplete(); return; } } if (e != 0 && r != long.MaxValue) { Interlocked.Add(ref requested, -e); } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
internal void Drain() { if (!QueueDrainHelper.Enter(ref wip)) { return; } int missed = 1; var a = actual; for (;;) { long r = Volatile.Read(ref requested); long e = 0L; while (e != r) { if (Volatile.Read(ref cancelled)) { inner = null; return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); inner = null; a.OnError(ex); return; } bool d = Volatile.Read(ref done); var inr = Volatile.Read(ref inner); d = d && (inr == null || inr.IsDone()); R v; bool empty; if (inr != null) { try { empty = !inr.queue.Poll(out v); } catch (Exception exc) { ExceptionHelper.ThrowIfFatal(exc); ExceptionHelper.AddError(ref error, exc); s.Cancel(); inner = null; exc = ExceptionHelper.Terminate(ref error); a.OnError(exc); return; } } else { v = default(R); empty = true; } if (d && empty) { inner = null; a.OnComplete(); return; } if (empty) { break; } a.OnNext(v); e++; inner.RequestOne(); } if (e == r) { if (Volatile.Read(ref cancelled)) { inner = null; return; } Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); inner = null; a.OnError(ex); return; } bool d = Volatile.Read(ref done); var inr = Volatile.Read(ref inner); d = d && (inr == null || inr.IsDone()); bool empty = inr == null || inr.queue.IsEmpty(); if (d && empty) { inner = null; a.OnComplete(); return; } } if (e != 0L && r != long.MaxValue) { Interlocked.Add(ref requested, -e); } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }
public void Drain() { if (!QueueDrainHelper.Enter(ref wip)) { return; } var a = actual; var s = subscribers; var c = current; int n = s.Length; int missed = 1; for (;;) { long r = Volatile.Read(ref requested); long e = 0L; for (;;) { if (!delayErrors) { Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); ClearAll(); ClearCurrent(); a.OnError(ex); return; } } int done = 0; int hasValue = 0; for (int i = 0; i < n; i++) { var inner = s[i]; if (inner.IsDone()) { done++; if (!inner.NonEmpty()) { CancelAll(); ClearAll(); ClearCurrent(); a.OnComplete(); return; } } if (inner.HasValue()) { hasValue++; } else { if (inner.Poll(out c[i])) { inner.HasValue(true); hasValue++; } } } if (done == n && hasValue != n) { Exception ex = Volatile.Read(ref error); if (ex != null) { ex = ExceptionHelper.Terminate(ref error); ClearCurrent(); a.OnError(ex); } else { a.OnComplete(); } return; } if (hasValue != n) { break; } if (e == r) { break; } var row = new T[n]; for (int i = 0; i < n; i++) { row[i] = current[i]; var inner = s[i]; inner.HasValue(false); inner.RequestOne(); } R t; try { t = zipper(row); } catch (Exception ex) { ExceptionHelper.ThrowIfFatal(ex); ExceptionHelper.AddError(ref error, ex); ex = ExceptionHelper.Terminate(ref error); CancelAll(); ClearAll(); ClearCurrent(); a.OnError(ex); return; } if (a.TryOnNext(t)) { e++; } } if (e != 0L && r != long.MaxValue) { Interlocked.Add(ref requested, -e); } missed = QueueDrainHelper.Leave(ref wip, missed); if (missed == 0) { break; } } }