public override bool TryOnNext(T item)
{
if (fusionMode == FusionSupport.NONE)
{
bool b;
try
{
b = predicate(item);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
if (b)
{
return(actual.TryOnNext(item));
}
return(false);
}
return(actual.TryOnNext(default(T)));
}
public override bool TryOnNext(T element)
{
if (done)
{
return(false);
}
if (fusionMode == FusionSupport.NONE)
{
if (!gate)
{
bool b;
try
{
b = predicate(element);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
if (!b)
{
gate = true;
return(actual.TryOnNext(element));
}
return(false);
}
return(actual.TryOnNext(element));
}
return(actual.TryOnNext(default(T)));
}
public void OnNext(T t)
{
if (done)
{
return;
}
long r = Volatile.Read(ref requested);
long p = produced;
if (p != r)
{
if (actual.TryOnNext(t))
{
produced = p + 1;
}
}
else
{
try
{
onDrop?.Invoke(t);
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
s.Cancel();
OnError(ex);
}
}
}
public override bool TryOnNext(T item)
{
if (done)
{
return(false);
}
if (fusionMode == FusionSupport.NONE)
{
bool b;
try
{
b = comparer.Equals(latest, item);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
if (!b)
{
latest = item;
return(actual.TryOnNext(item));
}
latest = item;
return(false);
}
actual.OnNext(default(T));
return(true);
}
public bool TryOnNext(T element)
{
if (done)
{
return(false);
}
try
{
onNext?.Invoke(element);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
bool b = actual.TryOnNext(element);
try
{
onAfterNext?.Invoke(element);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
return(b);
}
public bool TryOnNext(T t)
{
if (!hasValue)
{
hasValue = true;
}
return(actual.TryOnNext(t));
}
public bool TryOnNext(T item)
{
long now = executor.Now;
if (!once)
{
once = true;
last = now;
return(actual.TryOnNext(item));
}
if (last + delay <= now)
{
last = now;
return(actual.TryOnNext(item));
}
return(false);
}
public bool TryOnNext(T t)
{
if (actual.TryOnNext(t))
{
produced++;
return(true);
}
return(false);
}
public bool TryOnNext(T element)
{
if (actual.TryOnNext(element))
{
consumed++;
return(true);
}
return(false);
}
public bool TryOnNext(T t)
{
long prev = last;
long curr = scheduler.NowUtc;
last = curr;
return(actual.TryOnNext(new Timed <T>(t, curr - prev)));
}
public bool TryOnNext(T t)
{
if (won)
{
return(actual.TryOnNext(t));
}
else
if (parent.TryWin(index))
{
won = true;
return(actual.TryOnNext(t));
}
else
{
Cancel();
return(false);
}
}
public override bool TryOnNext(T element)
{
long n = remaining;
if (n > 0)
{
remaining = n - 1;
return(true);
}
return(actual.TryOnNext(element));
}
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 override bool TryOnNext(T element)
{
if (!done)
{
if (fusionMode == FusionSupport.NONE)
{
long remaining = this.remaining - 1;
if (remaining == 0)
{
upstream.Cancel();
done = true;
actual.TryOnNext(element);
actual.OnComplete();
return(false);
}
this.remaining = remaining;
return(actual.TryOnNext(element));
}
return(actual.TryOnNext(default(T)));
}
return(false);
}
public override bool TryOnNext(T item)
{
if (fusionMode == FusionSupport.NONE)
{
if (set.Add(item))
{
return(actual.TryOnNext(item));
}
return(false);
}
actual.OnNext(default(T));
return(true);
}
public override bool TryOnNext(T element)
{
if (fusionMode == FusionSupport.NONE)
{
R v;
try
{
v = mapper(element);
if (v == null)
{
throw new NullReferenceException("The mapper returned a null value");
}
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
return(actual.TryOnNext(v));
}
return(actual.TryOnNext(default(R)));
}
public bool TryOnNext(T t)
{
long z = size;
if (z != n)
{
queue.Offer(t);
size = z + 1;
return(true);
}
T u;
queue.Poll(out u);
queue.Offer(t);
return(actual.TryOnNext(u));
}
public bool TryOnNext(T element)
{
if (done)
{
return(false);
}
long retry = 0;
for (;;)
{
R v;
try
{
v = mapper(element);
}
catch (Exception ex)
{
switch (handler(++retry, ex))
{
case ParallelFailureMode.Error:
upstream.Cancel();
OnError(ex);
return(false);
case ParallelFailureMode.Skip:
return(false);
case ParallelFailureMode.Complete:
upstream.Cancel();
OnComplete();
return(false);
default:
continue;
}
}
return(actual.TryOnNext(v));
}
}
public override void Next(T t)
{
if (hasValue)
{
if (!terminated)
{
Error(new InvalidOperationException("The generator produced more than one value in a round."));
}
return;
}
if (fused)
{
value = t;
hasValue = true;
}
else
{
skipped = actual.TryOnNext(t);
}
}
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;
}
}
}
/// <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);
}
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);
}
public bool TryOnNext(T item)
{
if (done)
{
return(false);
}
bool v;
try
{
v = predicate(item);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
return(v && actual.TryOnNext(item));
}
public bool TryOnNext(T item)
{
if (done)
{
return(false);
}
R v;
try
{
v = mapper(item);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
return(actual.TryOnNext(v));
}
public override bool TryOnNext(T element)
{
if (done)
{
return(false);
}
if (fusionMode == FusionSupport.NONE)
{
try
{
parent.onNext?.Invoke(element);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
}
bool b = actual.TryOnNext(element);
if (fusionMode == FusionSupport.NONE)
{
try
{
parent.onAfterNext?.Invoke(element);
}
catch (Exception ex)
{
upstream.Cancel();
OnError(ex);
return(false);
}
}
return(b);
}
public bool TryOnNext(T t)
{
return(actual.TryOnNext(t));
}
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 bool TryOnNext(T element)
{
return(actual.TryOnNext(element));
}
public bool TryOnNext(T element)
{
return(actual.TryOnNext(element));
}
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;
}
}
}
