public void OnNext(T t)
{
if (doneOverflow)
{
return;
}
if (!q.Offer(t))
{
doneOverflow = true;
s.Cancel();
Exception e = BackpressureHelper.MissingBackpressureException();
try
{
onOverflow?.Invoke();
}
catch (Exception ex)
{
e = new AggregateException(e, ex);
}
error = e;
Volatile.Write(ref done, true);
}
Drain();
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
BackpressureHelper.ScalarPostCompleteRequest(ref requested, n, ref value, actual);
}
}
/// <summary>
/// Indicate the number of items produced and subtract it from
/// the current requested amount (if not unbounded).
/// </summary>
/// <param name="n">The produced amount, positive (not verified).</param>
public void Produced(long n)
{
if (Volatile.Read(ref wip) == 0 && Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
long r = requested;
if (r != long.MaxValue)
{
r -= n;
if (r < 0L)
{
ExceptionHelper.OnErrorDropped(new InvalidOperationException("More produced than requested: " + r));
r = 0L;
}
requested = r;
}
if (Interlocked.Decrement(ref wip) == 0)
{
return;
}
}
else
{
BackpressureHelper.GetAndAddCap(ref missedProduced, n);
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
}
Drain();
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
BackpressureHelper.PostCompleteRequest(ref requested, n, queue, actual, ref cancelled);
}
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
BackpressureHelper.Add(ref requested, n);
}
}
/// <summary>
/// Request the specified amount (not validated) from the current ISubscription if present
/// or accumulate it until an ISubscription is set.
/// </summary>
/// <param name="n">The request amount, positive (not validated)</param>
public void Request(long n)
{
if (Volatile.Read(ref wip) == 0 && Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
long r = requested;
var curr = current;
if (r != long.MaxValue)
{
requested = BackpressureHelper.AddCap(r, n);
}
if (Interlocked.Decrement(ref wip) != 0)
{
Drain();
}
curr?.Request(n);
}
else
{
BackpressureHelper.GetAndAddCap(ref missedRequested, n);
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
Drain();
}
}
public void Request(long n)
{
worker.Schedule(() =>
{
BackpressureHelper.DeferredRequest(ref s, ref requested, n);
});
}
/// <summary>
/// Requests the specified amount immediately or once the actual
/// subscription arrives (validated).
/// </summary>
/// <param name="n"></param>
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
BackpressureHelper.SingleRequest(ref this.s, ref requested, n);
}
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
ISubscription a = Volatile.Read(ref secondSubscription);
if (a == null)
{
BackpressureHelper.Add(ref requested, n);
a = Volatile.Read(ref secondSubscription);
if (a != null)
{
long r = Interlocked.Exchange(ref requested, 0);
if (r != 0)
{
a.Request(r);
}
}
}
else
{
a.Request(n);
}
}
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
BackpressureHelper.GetAndAddCap(ref requested, n);
}
}
/// <inheritdoc/>
public void Request(long n)
{
if (establishedFusionMode != FuseableHelper.SYNC)
{
BackpressureHelper.DeferredRequest(ref s, ref requested, n);
}
}
public void Complete(T t, ISubscriber <T> actual)
{
if (BackpressureHelper.SetValue(ref state, ref value, t))
{
actual.OnNext(t);
actual.OnComplete();
}
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
long u = BackpressureHelper.MultiplyCap(n, size);
s.Request(u);
}
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
BackpressureHelper.GetAndAddCap(ref requested, n);
parent.buffer.Drain(this);
}
}
public void OnSuccess(T t)
{
if (BackpressureHelper.SetValue(ref state, ref value, t))
{
actual.OnNext(t);
actual.OnComplete();
}
}
public override void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
long u = BackpressureHelper.MultiplyCap(n, size);
s.Request(u);
}
}
public void OnError(Exception e)
{
BackpressureHelper.Produced(ref requested, produced);
Signal <T> v = Signal <T> .CreateOnError(e);
value = v;
BackpressureHelper.ScalarPostComplete(ref requested, v, actual);
}
public void OnNext(T t)
{
if (!queue.Offer(t))
{
Cancel();
OnError(BackpressureHelper.MissingBackpressureException("Queue full?!"));
return;
}
Drain();
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (!BackpressureHelper.PostCompleteRequest(ref requested, n, actual, queue, ref cancelled))
{
s.Request(n);
}
}
}
public void OnNext(T t)
{
if (!queue.Offer(t))
{
s.Cancel();
OnError(BackpressureHelper.MissingBackpressureException());
return;
}
Schedule();
}
public override void OnComplete()
{
long p = produced;
if (p != 0L && Volatile.Read(ref requested) != long.MaxValue)
{
Interlocked.Add(ref requested, p);
}
BackpressureHelper.PostComplete <IList <T> >(ref requested, actual, lists, ref cancelled);
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
if (BackpressureHelper.SetRequest(ref state, ref value))
{
actual.OnNext(value);
actual.OnComplete();
}
}
}
public void OnNext(T t)
{
if (!q.Offer(t))
{
OnError(BackpressureHelper.MissingBackpressureException());
}
else
{
parent.Drain();
}
}
public void OnComplete()
{
if (!hasValue)
{
BackpressureHelper.PostComplete(ref requested, actual, this, ref cancelled);
}
else
{
actual.OnComplete();
}
}
public void OnNext(IOrderedItem <T> t)
{
if (fusionMode == FuseableHelper.NONE)
{
if (!queue.Offer(t))
{
OnError(BackpressureHelper.MissingBackpressureException("Queue full?!"));
return;
}
}
parent.Drain();
}
public override void OnNext(T t)
{
if (fusionMode != FuseableHelper.ASYNC)
{
if (!queue.Offer(t))
{
OnError(BackpressureHelper.MissingBackpressureException());
return;
}
}
Drain();
}
/// <summary>
/// Prepares the value to be the post-complete value.
/// </summary>
/// <param name="value">The value to signal post-complete.</param>
public void Complete(R value)
{
long p = produced;
if (p != 0L)
{
Produced(p);
}
last = value;
hasValue = true;
BackpressureHelper.PostComplete(ref requested, actual, this, ref cancelled);
}
internal void Request(int index, long n)
{
if (SubscriptionHelper.Validate(n))
{
var rs = requests;
BackpressureHelper.GetAndAddCap(ref rs[index], n);
if (Volatile.Read(ref subscriberCount) == rs.Length)
{
Drain();
}
}
}
internal void Enqueue(R value)
{
if (q.array == null)
{
q.InitVolatile(parent.bufferSize);
}
if (!q.Offer(value))
{
OnError(BackpressureHelper.MissingBackpressureException());
}
}
public void Request(long n)
{
if (OnSubscribeHelper.ValidateRequest(n))
{
BackpressureHelper.Add(ref requested, n);
var m = Volatile.Read(ref parent);
if (m != null)
{
m.Drain();
}
}
}
