public override void OnError(Exception error)
{
DisposeInners();
if (delayErrors)
{
if (!ExceptionHelper.AddException(ref errors, error))
{
base.Dispose();
return;
}
}
else
{
if (Interlocked.CompareExchange(ref errors, error, null) != null)
{
base.Dispose();
return;
}
}
if (Interlocked.Increment(ref wip) == 1)
{
var ex = ExceptionHelper.Terminate(ref errors);
downstream.OnError(ex);
base.Dispose();
}
}
internal void SubscribeAll(IEnumerable <ICompletableSource> sources)
{
Interlocked.Increment(ref active);
try
{
foreach (var src in sources)
{
var inner = new MergeInnerObserver(this);
if (!Add(inner))
{
break;
}
Interlocked.Increment(ref active);
src.Subscribe(inner);
}
}
catch (Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
}
Interlocked.Decrement(ref active);
Drain();
}
void InnerError(InnerObserver sender, Exception ex)
{
var c = Volatile.Read(ref current);
if (c == sender)
{
if (Interlocked.CompareExchange(ref current, null, c) == c)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
if (done && Volatile.Read(ref current) == null)
{
Terminate();
}
}
else
{
if (Interlocked.CompareExchange(ref errors, ex, null) == null)
{
Interlocked.Exchange(ref current, DISPOSED)?.Dispose();
Terminate();
}
}
}
}
}
internal override void Drain()
{
if (Interlocked.Increment(ref wip) == 1)
{
for (; ;)
{
if (DisposableHelper.IsDisposed(ref upstream))
{
Interlocked.Exchange(ref sources, null)?.Dispose();
}
else
{
var hasNext = false;
var next = default(ICompletableSource);
try
{
if (sources.MoveNext())
{
hasNext = true;
next = RequireNonNullRef(sources.Current, "The enumerator returned a null ICompletableSource");
}
}
catch (Exception ex)
{
DisposableHelper.WeakDispose(ref upstream);
ExceptionHelper.AddException(ref errors, ex);
ex = Volatile.Read(ref errors);
downstream.OnError(ex);
continue;
}
if (hasNext)
{
next.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;
}
}
}
}
internal void InnerError(Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
}
public void OnError(Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
}
else
{
errors = error;
}
Next();
}
public void OnError(Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
Next();
}
else
{
downstream.OnError(ex);
}
}
public void OnError(Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
Interlocked.Decrement(ref active);
Drain();
}
void InnerError(Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
active = false;
Drain();
}
public void InnerError(InnerSignalObserver <R> sender, Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
sender.SetDone();
Drain();
}
public void OnError(Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
Volatile.Write(ref done, true);
Drain();
}
public void OnError(Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref this.errors, error);
}
else
{
DisposableHelper.WeakDispose(ref upstream);
downstream.OnError(error);
}
Drain();
}
void InnerError(InnerObserver sender, Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
sender.SetDone();
}
else
{
Interlocked.CompareExchange(ref errors, error, null);
}
Drain();
}
void InnerError(InnerObserver sender, Exception ex)
{
Remove(sender);
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
Interlocked.Decrement(ref active);
Drain();
}
void TryEmitScalar(IDynamicValue <R> d)
{
var v = default(R);
var success = false;
try
{
v = d.GetValue(out success);
}
catch (Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
Interlocked.CompareExchange(ref errors, ex, null);
}
Drain();
return;
}
if (success)
{
if (Interlocked.CompareExchange(ref wip, 1, 0) == 0)
{
downstream.OnNext(v);
if (Interlocked.Decrement(ref wip) == 0)
{
return;
}
}
else
{
var q = scalarQueue;
if (q == null)
{
q = new SpscLinkedArrayQueue <R>(capacityHint);
Volatile.Write(ref scalarQueue, q);
}
q.TryOffer(v);
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
}
DrainLoop();
}
}
void SignalError(InnerObserver sender, Exception ex)
{
Remove(sender);
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
Interlocked.Decrement(ref active);
}
else
{
upstream.Dispose();
Interlocked.CompareExchange(ref errors, ex, null);
}
Drain();
}
protected override void InnerError(Exception ex, InnerObserver sender)
{
Remove(sender);
if (delayErrors)
{
ExceptionHelper.AddException(ref this.errors, ex);
Interlocked.Decrement(ref active);
Drain();
}
else
{
if (Interlocked.CompareExchange(ref this.errors, ex, null) == null)
{
Drain();
}
}
}
public void OnError(Exception error)
{
if (done)
{
return;
}
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
}
else
{
Interlocked.CompareExchange(ref errors, error, null);
}
done = true;
Drain();
}
public void OnError(Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
Volatile.Write(ref done, true);
Drain();
}
else
{
if (Interlocked.CompareExchange(ref errors, error, null) == null)
{
Volatile.Write(ref done, true);
Drain();
}
}
DisposableHelper.Dispose(ref upstream);
}
public override void OnError(Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref this.errors, error);
if (Interlocked.Decrement(ref active) == 0)
{
Drain();
}
}
else
{
if (Interlocked.CompareExchange(ref this.errors, error, null) == null)
{
Drain();
}
}
}
internal void InnerError(InnerObserver sender, Exception ex)
{
if (delayErrors)
{
if (ExceptionHelper.AddException(ref error, ex))
{
sender.SetDone();
Drain();
}
}
else
{
if (Interlocked.CompareExchange(ref error, ex, null) == null)
{
Drain();
}
}
}
void InnerError(Exception ex)
{
if (delayErrors)
{
if (ExceptionHelper.AddException(ref error, ex))
{
Interlocked.Increment(ref done);
Drain();
}
}
else
{
if (Interlocked.CompareExchange(ref error, ex, null) == null)
{
Drain();
}
}
}
void InnerError(Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, ex);
}
else
{
if (Interlocked.CompareExchange(ref errors, ex, null) == null)
{
if (Interlocked.Increment(ref wip) == 1)
{
ex = ExceptionHelper.Terminate(ref errors);
downstream.OnError(ex);
Dispose();
}
}
}
}
public override void OnError(Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref this.errors, error);
Volatile.Write(ref done, true);
if (Volatile.Read(ref active) == 0)
{
Drain();
}
}
else
{
if (Interlocked.CompareExchange(ref this.errors, error, null) == null)
{
Drain();
}
}
}
public void OnError(Exception error)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
}
else
{
if (Interlocked.CompareExchange(ref errors, error, null) == null)
{
Interlocked.Exchange(ref current, null)?.Dispose();
}
}
done = true;
if (Volatile.Read(ref current) == null)
{
Terminate();
}
}
void InnerError(int index, Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref error, ex);
if (Interlocked.Decrement(ref ready) == 0)
{
Volatile.Write(ref values, null);
downstream.OnError(error);
}
}
else
{
DisposeAll();
if (Interlocked.Exchange(ref ready, 0) > 0)
{
Volatile.Write(ref values, null);
downstream.OnError(ex);
}
}
}
public void InnerError(InnerObserver <R> sender, Exception error)
{
sender.Dispose();
if (Volatile.Read(ref active) == sender)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
sender.SetDone();
Drain();
}
else
{
if (Interlocked.CompareExchange(ref errors, error, null) == null)
{
sender.SetDone();
Drain();
}
}
}
}
public override void OnError(Exception error)
{
if (done)
{
return;
}
if (delayErrors)
{
ExceptionHelper.AddException(ref errors, error);
Volatile.Write(ref done, true);
Drain();
}
else
{
if (Interlocked.CompareExchange(ref errors, error, null) == null)
{
Volatile.Write(ref done, true);
Drain();
}
}
base.Dispose();
}
void Drain()
{
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
var missed = 1;
var downstream = this.downstream;
var queue = this.queue;
var observers = this.observers;
var n = observers.Length;
var values = this.values;
var hasLatest = this.hasLatest;
for (; ;)
{
for (; ;)
{
if (Volatile.Read(ref disposed))
{
while (queue.TryDequeue(out var _))
{
;
}
for (int i = 0; i < n; i++)
{
values[i] = default(T);
}
break;
}
if (!delayErrors)
{
var ex = Volatile.Read(ref error);
if (ex != null)
{
downstream.OnError(ex);
Volatile.Write(ref disposed, true);
DisposeAll();
continue;
}
}
var d = Volatile.Read(ref done) == n;
var empty = !queue.TryDequeue(out var v);
if (d && empty)
{
var ex = Volatile.Read(ref error);
if (ex != null)
{
downstream.OnError(ex);
}
else
{
downstream.OnCompleted();
}
Volatile.Write(ref disposed, true);
DisposeAll();
continue;
}
if (empty)
{
break;
}
var idx = v.index;
if (!hasLatest[idx])
{
hasLatest[idx] = true;
available++;
}
values[idx] = v.value;
if (available == n)
{
var result = default(R);
try
{
var a = new T[n];
Array.Copy(values, a, n);
result = mapper(a);
}
catch (Exception ex)
{
if (delayErrors)
{
ExceptionHelper.AddException(ref error, ex);
ex = ExceptionHelper.Terminate(ref error);
downstream.OnError(ex);
Volatile.Write(ref disposed, true);
DisposeAll();
}
else
{
if (Interlocked.CompareExchange(ref error, ex, null) == null)
{
downstream.OnError(ex);
Volatile.Write(ref disposed, true);
DisposeAll();
}
}
continue;
}
downstream.OnNext(result);
}
}
missed = Interlocked.Add(ref wip, -missed);
if (missed == 0)
{
break;
}
}
}
internal override void Drain()
{
if (Interlocked.Increment(ref wip) == 1)
{
for (; ;)
{
var srcs = sources;
var n = srcs.Length;
if (DisposableHelper.IsDisposed(ref upstream))
{
for (int i = index; i < n; i++)
{
srcs[i] = null;
}
}
else
{
var i = index;
if (i == n)
{
DisposableHelper.WeakDispose(ref upstream);
var ex = Volatile.Read(ref errors);
if (ex != null)
{
downstream.OnError(ex);
}
else
{
downstream.OnCompleted();
}
}
else
{
var src = srcs[i];
if (src == null)
{
DisposableHelper.WeakDispose(ref upstream);
ExceptionHelper.AddException(ref errors, new NullReferenceException("The " + i + "th ICompletableSource is null"));
var ex = Volatile.Read(ref errors);
downstream.OnError(ex);
continue;
}
else
{
srcs[i] = null;
index = i + 1;
src.Subscribe(this);
}
}
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
}