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();
}
}
}
public virtual void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.Validate(ref this.s, s))
{
qs = s as IQueueSubscription <T>;
if (BeforeSubscribe())
{
actual.OnSubscribe(this);
AfterSubscribe();
}
}
}
public override void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (Volatile.Read(ref once) == 0 && Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
if (n >= this.n)
{
s.Request(long.MaxValue);
return;
}
}
s.Request(n);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.Validate(ref this.s, s))
{
actual.OnSubscribe(this);
if (maxConcurrency == int.MaxValue)
{
s.Request(long.MaxValue);
}
else
{
s.Request(maxConcurrency);
}
}
}
public override void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (Volatile.Read(ref once) == 0 && Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
long u = BackpressureHelper.MultiplyCap(n - 1, skip);
long v = BackpressureHelper.AddCap(u, size);
s.Request(v);
}
else
{
long u = BackpressureHelper.MultiplyCap(n, skip);
s.Request(u);
}
}
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (BackpressureHelper.GetAndAddCap(ref requested, n) == 0)
{
if (n == long.MaxValue)
{
FastPath();
}
else
{
SlowPath(n);
}
}
}
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
if (fusionMode == FuseableHelper.ASYNC)
{
actual.OnNext(default(T));
}
else
{
actual.OnError(error);
}
}
}
}
public override void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (!BackpressureHelper.PostCompleteRequest <IList <T> >(ref requested, n, actual, lists, ref cancelled))
{
if (Volatile.Read(ref once) == 0 && Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
long r = BackpressureHelper.MultiplyCap(n - 1, size - skip);
long u = BackpressureHelper.AddCap(r, size);
s.Request(u);
}
else
{
long r = BackpressureHelper.MultiplyCap(n, size - skip);
s.Request(r);
}
}
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.Validate(ref this.s, s))
{
var qs = s as IQueueSubscription <T>;
if (qs != null)
{
int mode = qs.RequestFusion(FuseableHelper.ANY | FuseableHelper.BOUNDARY);
if (mode == FuseableHelper.SYNC)
{
this.sourceMode = mode;
this.queue = qs;
Volatile.Write(ref done, true);
SubscribeActual();
Schedule();
return;
}
else
if (mode == FuseableHelper.ASYNC)
{
this.sourceMode = mode;
this.queue = qs;
SubscribeActual();
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
return;
}
}
queue = QueueDrainHelper.CreateQueue <T>(prefetch);
SubscribeActual();
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.Validate(ref this.s, s))
{
var qs = s as IQueueSubscription <T>;
if (qs != null)
{
int m = qs.RequestFusion(FuseableHelper.ANY);
if (m == FuseableHelper.SYNC)
{
fusionMode = m;
queue = qs;
Volatile.Write(ref done, true);
actual.OnSubscribe(this);
Drain();
return;
}
else
if (m == FuseableHelper.ASYNC)
{
fusionMode = m;
queue = qs;
actual.OnSubscribe(this);
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
return;
}
}
queue = QueueDrainHelper.CreateQueue <T>(prefetch);
actual.OnSubscribe(this);
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
}
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
for (;;)
{
long r = Volatile.Read(ref requested);
if (r == long.MinValue)
{
break;
}
long u = r + n;
if (u < 0L)
{
u = long.MaxValue;
}
if (Interlocked.CompareExchange(ref requested, u, r) == r)
{
break;
}
}
}
}
