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 OnComplete()
{
if (!hasValue)
{
BackpressureHelper.PostComplete(ref requested, actual, this, ref cancelled);
}
else
{
actual.OnComplete();
}
}
/// <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);
}
public void OnComplete()
{
if (done)
{
return;
}
long p = produced;
if (p != 0L && Volatile.Read(ref requested) != long.MaxValue)
{
Interlocked.Add(ref requested, -p);
}
BackpressureHelper.PostComplete(ref requested, buffers, actual, ref cancelled);
}
public void OnComplete()
{
BackpressureHelper.PostComplete(ref requested, actual, queue, ref cancelled);
}
public void OnComplete()
{
Trim(scheduler.NowUtc());
BackpressureHelper.PostComplete(ref requested, q, actual, ref cancelled, v => v.value);
}
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;
}
}
}
