public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.Validate(ref upstream, subscription)) { OnSubscribe(); subscription.Request(bufferSize); } }
public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.Validate(ref upstream, subscription)) { OnStart(); subscription.Request(long.MaxValue); } }
public void Cancel() { Volatile.Write(ref cancelled, true); SubscriptionHelper.Cancel(ref upstream); boundary.Cancel(); lock (this) { buffer = default(C); } }
internal void CompleteLast(T entry) { long p = produced; if (p != 0L) { SubscriptionHelper.Produced(ref requested, p); } SubscriptionHelper.PostCompleteSingleResult(parent.actual, ref requested, ref last, entry, ref cancelled); }
public void OnError(Exception cause) { long p = produced; if (p != 0L) { SubscriptionHelper.Produced(ref requested, p); } SubscriptionHelper.PostCompleteSingleResult(actual, ref requested, ref fallback, fallback, ref cancelled); }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (SubscriptionHelper.AddRequest(ref requested, n) == 0) { OnRequest(n); } } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { SubscriptionHelper.AddRequest(ref requested, n); if (Volatile.Read(ref done) == 0) { Drain(); } } }
public void OnComplete() { if (hasValue) { actual.OnComplete(); } else { SubscriptionHelper.PostCompleteSingleResult(actual, ref requested, ref defaultItem, defaultItem, ref cancelled); } }
public void Request(long n) { if (n <= 0L) { throw new ArgumentOutOfRangeException(nameof(n)); } if (SubscriptionHelper.AddRequest(ref requested, n) == 0) { OnRequest(n); } }
void Request(int index, long n) { if (SubscriptionHelper.Validate(n)) { SubscriptionHelper.AddRequest(ref subscribers[index].requested, n); } if (Volatile.Read(ref initDone)) { Drain(); } }
public void OnComplete() { if (done) { return; } done = true; SubscriptionHelper.Cancel(ref otherSubscriber.upstream); latest = null; SerializationHelper.OnComplete(actual, ref wip, ref error); }
public void OnError(Exception cause) { if (done) { return; } done = true; SubscriptionHelper.Cancel(ref otherSubscriber.upstream); latest = null; SerializationHelper.OnError(actual, ref wip, ref error, cause); }
void BoundaryError(Exception cause) { SubscriptionHelper.Cancel(ref upstream); lock (this) { buffer = default(C); error = cause; } Volatile.Write(ref done, true); Drain(); }
void Drain() { if (outputFused) { SubscriptionHelper.QueueDrainFused(actual, ref wip, queue, ref cancelled, ref done, ref error); } else { SubscriptionHelper.QueueDrain(actual, ref wip, queue, ref requested, ref emitted, ref cancelled, ref done, ref error); } }
public void Request(long n) { if (n <= 0L) { throw new ArgumentOutOfRangeException(nameof(n)); } if (SubscriptionHelper.AddRequest(ref requested, n) == 0) { int idx = index; int f = end; long e = 0; IConditionalSubscriber <int> a = actual; for (;;) { while (idx != f && e != n) { if (Volatile.Read(ref cancelled)) { return; } if (a.TryOnNext(idx)) { e++; } idx++; } if (idx == f) { if (!Volatile.Read(ref cancelled)) { a.OnComplete(); } return; } n = Volatile.Read(ref requested); if (e == n) { index = idx; n = Interlocked.Add(ref requested, -n); if (n == 0L) { break; } e = 0L; } } } }
public void Request(long n) { if (n <= 0L) { upstream.Cancel(); OnError(new ArgumentException("§3.9 violated: non-positive request received")); } else { SubscriptionHelper.DeferredRequest(ref upstream, ref requested, n); } }
public void OnSubscribe(ISubscription subscription) { if (Interlocked.CompareExchange(ref hasSubscribed, 1, 0) == 0) { actual.OnSubscribe(this); SubscriptionHelper.DeferredSetOnce(ref upstream, ref requested, subscription); } else { subscription.Cancel(); } }
public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.Validate(ref upstream, subscription)) { actual.OnSubscribe(this); var b = bufferSize - 1; if (b != 0) { subscription.Request(b); } } }
public void OnComplete() { Volatile.Write(ref done, true); if (outputFused) { actual.OnNext(default(T)); actual.OnComplete(); } else { SubscriptionHelper.PostCompleteMultiResult(actual, ref requested, queue, ref cancelled); } }
public void Cancel() { SubscriptionHelper.Cancel(ref upstream); foreach (var inner in others) { SubscriptionHelper.Cancel(ref inner.upstream); } var ls = latest; for (int i = 0; i < ls.Length; i++) { ls[i] = null; } }
public void OnSubscribe(ISubscription subscription) { if (SubscriptionHelper.Validate(ref upstream, subscription)) { SequentialDisposable sd = new SequentialDisposable(); timer = sd; ArbiterSet(subscription); actual.OnSubscribe(this); sd.Set(worker.Schedule(() => Timeout(0), firstTimeout)); } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { long u = SubscriptionHelper.MultiplyCap(n, skip); if (Volatile.Read(ref firstRequest) == 0 && Interlocked.CompareExchange(ref firstRequest, 1, 0) == 0) { if (u != long.MaxValue) { u -= (skip - size); } } upstream.Request(u); } }
void OtherError(Exception ex, int index) { SubscriptionHelper.Cancel(ref upstream); var os = others; var n = os.Length; for (int i = 0; i < n; i++) { if (i != index) { SubscriptionHelper.Cancel(ref os[i].upstream); } } SerializationHelper.OnError(actual, ref wip, ref error, ex); }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { SubscriptionHelper.AddRequest(ref requested, n); if (outputFused) { DrainFused(); } else { Drain(); } } }
public void Request(long n) { if (!SubscriptionHelper.PostCompleteMultiRequest(actual, ref requested, queue, n, ref cancelled)) { long u = SubscriptionHelper.MultiplyCap(n, size - skip); if (Volatile.Read(ref firstRequest) == 0 && Interlocked.CompareExchange(ref firstRequest, 1, 0) == 0) { u += skip; if (u < 0L) { u = long.MaxValue; } } upstream.Request(u); } }
void BoundaryComplete() { SubscriptionHelper.Cancel(ref upstream); lock (this) { var b = buffer; if (b == null) { return; } buffer = default(C); queue.Offer(b); } Volatile.Write(ref done, true); Drain(); }
public void OnComplete() { if (done) { return; } done = true; foreach (var inner in others) { SubscriptionHelper.Cancel(ref inner.upstream); } for (int i = 0; i < latest.Length; i++) { latest[i] = null; } SerializationHelper.OnComplete(actual, ref wip, ref error); }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { SubscriptionHelper.AddRequest(ref requested, n); long u = SubscriptionHelper.MultiplyCap(n, size - skip); if (Volatile.Read(ref firstRequest) == 0 && Interlocked.CompareExchange(ref firstRequest, 1, 0) == 0) { u += skip; if (u < 0L) { u = long.MaxValue; } } upstream.Request(u); } }
void OtherComplete(int index) { if (Volatile.Read(ref latest[index]) == null) { SubscriptionHelper.Cancel(ref upstream); var os = others; var n = os.Length; for (int i = 0; i < n; i++) { if (i != index) { SubscriptionHelper.Cancel(ref os[i].upstream); } } SerializationHelper.OnComplete(actual, ref wip, ref error); } }
public void OnSubscribe(ISubscription subscription) { if (requestOn) { if (SubscriptionHelper.SetOnce(ref upstream, subscription)) { long r = Interlocked.Exchange(ref requested, 0L); if (r != 0L) { worker.Schedule(() => upstream.Request(r)); } } } else { SubscriptionHelper.DeferredSetOnce(ref upstream, ref requested, subscription); } }