public void OnCompleted()
{
if (Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
if (!terminated)
{
terminated = true;
Volatile.Write(ref done, true);
downstream.OnCompleted();
Dispose();
if (Interlocked.Decrement(ref wip) == 0)
{
return;
}
}
}
else
{
Volatile.Write(ref done, true);
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
}
DrainLoop();
}
public void OnCompleted()
{
if (Volatile.Read(ref state) == StateFused)
{
Volatile.Write(ref state, StateReady);
downstream.OnNext(default(T));
if (!Volatile.Read(ref disposed))
{
downstream.OnCompleted();
}
}
else
{
var queue = this.queue;
while (queue.Count != 0)
{
if (Volatile.Read(ref disposed))
{
return;
}
downstream.OnNext(queue.Dequeue());
}
if (Volatile.Read(ref disposed))
{
return;
}
downstream.OnCompleted();
}
}
public void OnCompleted()
{
if (remaining > 0)
{
downstream.OnCompleted();
}
}
public void OnCompleted()
{
if (hasValue)
{
downstream.OnCompleted();
}
else
{
Run(null);
}
}
public void OnCompleted()
{
if (won || parent.TryWin(index))
{
downstream.OnCompleted();
}
}
public virtual void OnCompleted()
{
if (done)
{
return;
}
downstream.OnCompleted();
}
internal void Run()
{
if (DisposableHelper.IsDisposed(ref task))
{
return;
}
if (fused)
{
var fr = fusedReady;
if (fr == end)
{
downstream.OnCompleted();
Dispose();
}
else
{
Volatile.Write(ref fusedReady, fr + 1);
downstream.OnNext(default(long));
if (fr + 1 == end)
{
downstream.OnCompleted();
Dispose();
}
}
}
else
{
var idx = index;
if (idx == end)
{
downstream.OnCompleted();
Dispose();
}
else
{
index = idx + 1;
downstream.OnNext(idx);
if (idx + 1 == end)
{
downstream.OnCompleted();
Dispose();
}
}
}
}
public void OnCompleted()
{
if (upstream != DisposableHelper.DISPOSED)
{
DisposableHelper.WeakDispose(ref upstream);
downstream.OnCompleted();
}
}
public void OnCompleted()
{
while (windows.Count != 0)
{
windows.Dequeue().OnCompleted();
}
downstream.OnCompleted();
}
internal void Next()
{
if (Interlocked.Increment(ref wip) == 1)
{
for (; ;)
{
if (DisposableHelper.IsDisposed(ref upstream))
{
sources?.Dispose();
sources = null;
}
else
{
var b = false;
var src = default(IObservableSource <T>);
try
{
b = sources.MoveNext();
if (b)
{
src = ValidationHelper.RequireNonNullRef(sources.Current, "The enumerator returned a null IObservableSource");
}
}
catch (Exception ex)
{
DisposableHelper.WeakDispose(ref upstream);
downstream.OnError(ex);
continue;
}
if (b)
{
src.Subscribe(this);
}
else
{
DisposableHelper.WeakDispose(ref upstream);
var ex = Volatile.Read(ref errors);
if (ex != null)
{
downstream.OnError(ex);
}
else
{
downstream.OnCompleted();
}
continue;
}
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
}
public void OnCompleted()
{
if (done)
{
return;
}
done = true;
downstream.OnCompleted();
}
public void OnCompleted()
{
var d = Interlocked.Exchange(ref resource, DisposableHelper.DISPOSED);
if (d != DisposableHelper.DISPOSED)
{
downstream.OnCompleted();
d?.Dispose();
}
}
public static void OnCompleted <T>(ISignalObserver <T> observer, ref int wip, ref Exception error)
{
if (Interlocked.CompareExchange(ref error, ExceptionHelper.TERMINATED, null) == null)
{
if (Interlocked.Increment(ref wip) == 1)
{
observer.OnCompleted();
}
}
}
public void OnCompleted()
{
if (other == null)
{
downstream.OnCompleted();
}
else
{
Subscribe(null);
}
}
internal void Run()
{
if (Volatile.Read(ref state) == ModeFresh)
{
downstream.OnNext(item);
if (Volatile.Read(ref state) == 0)
{
Volatile.Write(ref state, ModeDone);
downstream.OnCompleted();
}
}
}
public void Complete(T result)
{
var s = Volatile.Read(ref state);
if (s == Empty)
{
downstream.OnNext(result);
if (Volatile.Read(ref state) != Disposed)
{
downstream.OnCompleted();
}
}
else
if (s == FusedEmpty)
{
value = result;
Volatile.Write(ref state, FusedReady);
downstream.OnNext(default(T));
downstream.OnCompleted();
}
}
internal void Run()
{
var s = Volatile.Read(ref state);
if (s == Empty)
{
downstream.OnNext(0L);
if (Volatile.Read(ref state) != Disposed)
{
Volatile.Write(ref state, Disposed);
downstream.OnCompleted();
}
}
else
if (s == FusedEmpty)
{
Volatile.Write(ref state, FusedReady);
downstream.OnNext(default(long));
downstream.OnCompleted();
}
}
public void OnCompleted()
{
if (done)
{
return;
}
var b = buffer;
buffer = default;
if (b != null)
{
downstream.OnNext(b);
}
downstream.OnCompleted();
}
internal void Handle(Task t)
{
if (t.IsCanceled)
{
observer?.OnError(new OperationCanceledException());
}
else
if (t.IsFaulted)
{
observer?.OnError(t.Exception);
}
else
{
observer?.OnCompleted();
}
}
internal void Run()
{
if (fused)
{
return;
}
for (; ;)
{
if (Volatile.Read(ref disposed))
{
enumerator?.Dispose();
enumerator = null;
break;
}
else
{
var v = default(T);
var has = false;
try
{
has = enumerator.MoveNext();
if (has)
{
v = enumerator.Current;
}
}
catch (Exception ex)
{
downstream.OnError(ex);
break;
}
if (has)
{
downstream.OnNext(v);
}
else
{
downstream.OnCompleted();
Volatile.Write(ref disposed, true);
}
}
}
}
internal void Next()
{
if (Interlocked.Increment(ref wip) == 1)
{
for (; ;)
{
var idx = index;
if (idx == sources.Length)
{
var ex = Volatile.Read(ref errors);
if (ex != null)
{
downstream.OnError(ex);
}
else
{
downstream.OnCompleted();
}
}
else
{
var src = sources[idx];
if (src == null)
{
downstream.OnError(new NullReferenceException($"sources[{idx}] is null"));
}
else
{
index = idx + 1;
src.Subscribe(this);
}
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
}
public static void OnNext <T>(ISignalObserver <T> observer, T item, ref int wip, ref Exception error)
{
if (Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
observer.OnNext(item);
if (Interlocked.Decrement(ref wip) != 0)
{
var ex = Volatile.Read(ref error);
if (ex != ExceptionHelper.TERMINATED)
{
observer.OnError(ex);
}
else
{
observer.OnCompleted();
}
}
}
}
public void OnCompleted()
{
if (done)
{
return;
}
var buffers = this.buffers;
while (buffers.Count != 0)
{
if (Volatile.Read(ref disposed))
{
buffers.Clear();
return;
}
downstream.OnNext(buffers.Dequeue());
}
downstream.OnCompleted();
}
public void OnCompleted()
{
if (done)
{
return;
}
try
{
onCompleted?.Invoke();
}
catch (Exception ex)
{
OnError(ex);
return;
}
try
{
onTerminate?.Invoke();
}
catch (Exception ex)
{
OnErrorCore(ex, false);
return;
}
downstream.OnCompleted();
try
{
onAfterTerminate?.Invoke();
}
catch (Exception)
{
// TODO where to put these?
}
DoFinally();
}
internal static void EmitAll <T>(this ISignalObserver <T> subject, params T[] items)
{
Emit(subject, items);
subject.OnCompleted();
}
public void OnCompleted()
{
downstream.OnCompleted();
}
public void OnCompleted()
{
queue.Clear();
downstream.OnCompleted();
}
public void OnCompleted()
{
downstream.OnCompleted();
parent.Terminate();
}
protected override void Completed()
{
observer.OnCompleted();
}
public void OnCompleted()
{
window?.OnCompleted();
window = null;
downstream.OnCompleted();
}
