public override void OnComplete()
{
if (!done)
{
done = true;
actual.OnComplete();
}
}
public void OnComplete()
{
if (won)
{
actual.OnComplete();
}
else
if (parent.TryWin(index))
{
actual.OnComplete();
}
}
public void OnComplete()
{
if (Interlocked.Increment(ref wip) == 1)
{
var a = sources;
do
{
if (ArbiterIsCancelled())
{
break;
}
int idx = index;
if (idx == a.Length)
{
actual.OnComplete();
return;
}
var p = a[idx];
if (p == null)
{
actual.OnError(new NullReferenceException("One of the IPublishers was null"));
return;
}
index = idx + 1;
long c = consumed;
if (c != 0L)
{
consumed = 0L;
ArbiterProduced(c);
}
p.Subscribe(this);
}while (Interlocked.Decrement(ref wip) != 0);
}
}
public void OnComplete()
{
if (done)
{
return;
}
done = true;
actual.OnComplete();
}
/// <summary>
/// Complete the actual ISubscriber if the sequence is not already done.
/// </summary>
protected void Complete()
{
if (done)
{
return;
}
done = true;
actual.OnComplete();
}
public override void OnComplete()
{
if (done)
{
return;
}
latest = default(T);
done = true;
actual.OnComplete();
}
public void OnComplete()
{
try
{
actual.OnComplete();
}
finally
{
worker.Dispose();
}
}
public void OnComplete()
{
if (!hasValue)
{
BackpressureHelper.PostComplete(ref requested, actual, this, ref cancelled);
}
else
{
actual.OnComplete();
}
}
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 OnComplete()
{
if (hasValue)
{
actual.OnComplete();
}
else
{
hasValue = true;
other.Subscribe(this);
}
}
public override void Complete()
{
if (terminated)
{
return;
}
terminated = true;
if (!fused)
{
actual.OnComplete();
}
}
internal void Drain()
{
if (!QueueDrainHelper.Enter(ref wip))
{
return;
}
var a = sources;
for (;;)
{
if (!Volatile.Read(ref active))
{
int i = index;
if (i == a.Length)
{
Exception ex = error;
if (ex != null)
{
actual.OnError(ex);
}
else
{
actual.OnComplete();
}
return;
}
long p = produced;
if (p != 0L)
{
produced = 0L;
arbiter.Produced(p);
}
IPublisher <T> next = a[i];
index = i + 1;
Volatile.Write(ref active, true);
next.Subscribe(this);
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
public void OnComplete()
{
if (Interlocked.Increment(ref wip) == 1)
{
var a = sources;
var en = Volatile.Read(ref sources);
do
{
if (en == null || ArbiterIsCancelled())
{
break;
}
bool b;
try
{
b = en.MoveNext();
}
catch (Exception ex)
{
Dispose();
actual.OnError(ex);
return;
}
if (!b)
{
Dispose();
actual.OnComplete();
return;
}
var p = en.Current;
if (p == null)
{
Dispose();
actual.OnError(new NullReferenceException("One of the IPublishers was null"));
return;
}
long c = consumed;
if (c != 0L)
{
consumed = 0L;
ArbiterProduced(c);
}
p.Subscribe(this);
}while (Interlocked.Decrement(ref wip) != 0);
}
}
void DrainConditionalFused(IConditionalSubscriber <T> a)
{
var q = queue;
int missed = 1;
for (;;)
{
if (lvCancelled())
{
conditional = null;
q.Clear();
return;
}
bool d = lvDone();
a.TryOnNext(default(T));
if (d)
{
conditional = null;
Exception ex = error;
if (ex != null)
{
a.OnError(ex);
}
else
{
a.OnComplete();
}
return;
}
missed = QueueDrainHelper.Leave(ref wip, missed);
if (missed == 0)
{
break;
}
}
}
internal static bool TryOnNext <T>(IConditionalSubscriber <T> actual, ref int wip, ref Exception error, T item)
{
if (Volatile.Read(ref wip) == 0 && Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
bool b = actual.TryOnNext(item);
if (Interlocked.CompareExchange(ref wip, 0, 1) != 1)
{
var ex = Interlocked.Exchange(ref error, ExceptionHelper.Terminated);
if (ex == null)
{
actual.OnComplete();
}
else
{
actual.OnError(ex);
}
return(false);
}
return(b);
}
return(false);
}
/// <summary>
/// Signal an OnNext value conditionally and terminate if
/// there was a concurrent OnError or OnComplete call.
/// Should be called from one thread at a time.
/// </summary>
/// <typeparam name="T">The value type</typeparam>
/// <param name="actual">The target ISubscriber</param>
/// <param name="value">The value to signal</param>
/// <returns>What the TryOnNext returns or false if terminated</returns>
internal bool TryOnNext <T>(IConditionalSubscriber <T> actual, T value)
{
if (Volatile.Read(ref wip) == 0 && Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
bool b = actual.TryOnNext(value);
if (Interlocked.CompareExchange(ref wip, 0, 1) != 1)
{
var ex = ExceptionHelper.Terminate(ref error);
if (ex != null)
{
actual.OnError(ex);
}
else
{
actual.OnComplete();
}
return(false);
}
return(b);
}
return(false);
}
public override void OnComplete()
{
if (done)
{
return;
}
done = true;
try
{
parent.onComplete?.Invoke();
parent.onTerminated?.Invoke();
}
catch (Exception ex)
{
actual.OnError(ex);
AfterTerminated();
return;
}
actual.OnComplete();
AfterTerminated();
}
public override void OnComplete()
{
if (eager)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
try
{
resourceCleanup?.Invoke(resource);
}
catch (Exception ex)
{
actual.OnError(ex);
return;
}
}
}
actual.OnComplete();
if (!eager)
{
DisposeAfter();
}
}
void DrainConditional(IConditionalSubscriber <T> a)
{
var q = queue;
int missed = 1;
for (;;)
{
long r = Volatile.Read(ref requested);
long e = 0L;
while (e != r)
{
if (lvCancelled())
{
conditional = null;
q.Clear();
return;
}
bool d = lvDone();
T v;
bool empty = !q.Poll(out v);
if (d && empty)
{
conditional = null;
Exception ex = error;
if (ex != null)
{
a.OnError(ex);
}
else
{
a.OnComplete();
}
return;
}
if (empty)
{
break;
}
a.OnNext(v);
e++;
}
if (e == r)
{
if (lvCancelled())
{
conditional = null;
q.Clear();
return;
}
if (lvDone() && q.IsEmpty())
{
conditional = null;
Exception ex = error;
if (ex != null)
{
a.OnError(ex);
}
else
{
a.OnComplete();
}
return;
}
}
if (e != 0 && r != long.MaxValue)
{
Interlocked.Add(ref requested, -e);
}
missed = QueueDrainHelper.Leave(ref wip, missed);
if (missed == 0)
{
break;
}
}
}
public override void OnComplete()
{
actual.OnComplete();
Finally();
}
protected override void OnRequest(long n)
{
IConditionalSubscriber <T> a = actual;
IEnumerator <T> en = enumerator;
long e = 0L;
for (;;)
{
while (e != n)
{
if (Volatile.Read(ref cancelled) != 0)
{
Clear();
return;
}
T v = en.Current;
if (v == null)
{
Clear();
a.OnError(new NullReferenceException("One of the IEnumerator items is null"));
return;
}
if (a.TryOnNext(v))
{
e++;
}
bool b;
try
{
b = en.MoveNext();
}
catch (Exception ex)
{
Clear();
a.OnError(ex);
return;
}
if (!b)
{
Clear();
if (Volatile.Read(ref cancelled) == 0)
{
a.OnComplete();
}
return;
}
}
n = Volatile.Read(ref requested);
if (e == n)
{
n = Interlocked.Add(ref requested, -n);
if (n == 0L)
{
break;
}
e = 0L;
}
}
}
public void Request(long n)
{
if (n <= 0L)
{
throw new ArgumentOutOfRangeException(nameof(n));
}
if (SubscriptionHelper.AddRequest(ref requested, n) == 0)
{
int idx = index;
T[] array = this.array;
int f = array.Length;
long e = 0;
IConditionalSubscriber <T> a = actual;
for (;;)
{
while (idx != f && e != n)
{
if (Volatile.Read(ref cancelled))
{
return;
}
T v = array[idx];
if (v == null)
{
a.OnError(new NullReferenceException("An array item was null"));
return;
}
if (a.TryOnNext(v))
{
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 override void OnComplete()
{
set.Clear();
actual.OnComplete();
}
public void OnComplete()
{
actual.OnComplete();
}
internal void Drain()
{
if (!QueueDrainHelper.Enter(ref wip))
{
return;
}
var a = enumerator;
for (;;)
{
if (!Volatile.Read(ref active))
{
int i = index;
if (i != 0)
{
bool hasNext;
try
{
hasNext = enumerator.MoveNext();
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
Exception exc = error;
if (exc != null)
{
exc = new AggregateException(exc, ex);
}
actual.OnError(exc);
return;
}
if (!hasNext)
{
Exception ex = error;
if (ex != null)
{
actual.OnError(ex);
}
else
{
actual.OnComplete();
}
return;
}
}
long p = produced;
if (p != 0L)
{
produced = 0L;
arbiter.Produced(p);
}
IPublisher <T> next = a.Current;
index = i + 1;
Volatile.Write(ref active, true);
next.Subscribe(this);
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
