internal TakeConditionalSubscriber(IConditionalSubscriber <T> actual, long n, bool limitRequest)
{
this.actual = actual;
this.remaining = n;
this.limit = n;
this.limitRequest = limitRequest;
}
internal BaseOnErrorResumeWithConditionalSubscriber(IConditionalSubscriber <T> actual,
Func <Exception, bool> predicate, Func <Exception, IPublisher <T> > publisherFactory)
{
this.actual = actual;
this.predicate = predicate;
this.publisherFactory = publisherFactory;
}
internal TimeoutConditionalSubscriber(IConditionalSubscriber <T> actual, IPublisher <U> firstTimeout, Func <T, IPublisher <V> > itemTimeout, IPublisher <T> fallback)
{
this.actual = actual;
this.firstTimeout = firstTimeout;
this.itemTimeout = itemTimeout;
this.fallback = fallback;
}
public void Subscribe(ISubscriber <V> s)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
s.OnSubscribe(this);
if (s is IConditionalSubscriber <V> )
{
Volatile.Write(ref conditional, (IConditionalSubscriber <V>)s);
if (Volatile.Read(ref cancelled) != 0)
{
conditional = null;
return;
}
}
else
{
Volatile.Write(ref regular, s);
if (Volatile.Read(ref cancelled) != 0)
{
regular = null;
return;
}
}
Drain();
}
else
{
EmptySubscription <V> .Error(s, new InvalidOperationException("The IGroupedFlux allows only a single ISubscriber!"));
}
}
internal PeekConditionalSubscriber(IConditionalSubscriber <T> actual, ParallelFlowablePeek <T> parent)
{
this.actual = actual;
this.parent = parent;
this.onNext = parent.onNext;
this.onAfterNext = parent.onAfterNext;
}
internal UsingConditionalSubscriber(IConditionalSubscriber <T> actual,
D resource, Action <D> resourceCleanup, bool eager)
{
this.actual = actual;
this.resource = resource;
this.resourceCleanup = resourceCleanup;
this.eager = eager;
}
internal ConcatBaseConditionalSubscriber(IConditionalSubscriber <R> actual, Func <T, IPublisher <R> > mapper, int prefetch)
{
this.actual = actual;
this.mapper = mapper;
this.prefetch = prefetch;
this.limit = prefetch - (prefetch >> 2);
this.inner = new ConcatInnerSubscriber(this);
}
internal AmbConditionalSubscription(IConditionalSubscriber <T> actual, int n)
{
var a = new AmbInnerConditionalSubscriber[n];
for (int i = 0; i < n; i++)
{
a[i] = new AmbInnerConditionalSubscriber(this, actual, i);
}
winner = -1;
subscribers = a;
}
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;
}
}
}
}
internal ZipConditionalSubscription(IConditionalSubscriber <R> actual, int n, Func <T[], R> zipper, int prefetch, bool delayErrors)
{
this.actual = actual;
this.zipper = zipper;
this.current = new T[n];
var a = new ZipInnerSubscriber[n];
for (int i = 0; i < n; i++)
{
a[i] = new ZipInnerSubscriber(this, prefetch);
}
this.subscribers = a;
this.delayErrors = delayErrors;
}
internal CombineLatestConditionalSubscription(IConditionalSubscriber <R> actual, int prefetch, bool delayError, Func <T[], R> combiner, int n)
{
this.actual = actual;
this.prefetch = prefetch;
this.delayError = delayError;
this.combiner = combiner;
this.latest = new T[n];
var a = new CombineLatestSubscriber[n];
for (int i = 0; i < n; i++)
{
a[i] = new CombineLatestSubscriber(this, i, prefetch);
}
this.subscribers = a;
this.queue = new SpscLinkedArrayQueue <Entry>(prefetch);
}
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);
}
internal PeekConditionalSubscriber(
IConditionalSubscriber <T> actual,
Action <T> onNext,
Action <T> onAfterNext,
Action <Exception> onError,
Action onComplete,
Action onTerminate,
Action onAfterTerminate,
Action <long> onRequest,
Action <ISubscription> onSubscribe,
Action onCancel
) : base(actual)
{
this.onNext = onNext;
this.onAfterNext = onAfterNext;
this.onError = onError;
this.onComplete = onComplete;
this.onTerminate = onTerminate;
this.onAfterTerminate = onAfterTerminate;
this.onRequest = onRequest;
this.onSubscribe = onSubscribe;
this.onCancel = onCancel;
}
/// <inheritdoc/>
public void Subscribe(ISubscriber <T> s)
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
s.OnSubscribe(this);
if (s is IConditionalSubscriber <T> )
{
Volatile.Write(ref conditional, (IConditionalSubscriber <T>)s);
if (lvCancelled())
{
conditional = null;
}
else
{
Drain();
}
}
else
{
Volatile.Write(ref regular, s);
if (lvCancelled())
{
regular = null;
}
else
{
Drain();
}
}
}
else
{
EmptySubscription <T> .Error(s, new InvalidOperationException("Only a one ISubscriber allowed. Use Publish() or Replay() to share an UnicastProcessor."));
}
}
public DistinctUntilChangedConditionalSubscriber(IConditionalSubscriber <T> actual, Func <T, K> keySelector, IEqualityComparer <K> comparer) : base(actual)
{
this.keySelector = keySelector;
this.comparer = comparer;
}
internal SubscribeOnConditionalSubscriber(IConditionalSubscriber <T> actual, Worker worker)
{
this.actual = actual;
this.worker = worker;
}
internal WithLatestFromConditionalSubscriber(IConditionalSubscriber <R> actual, int n, Func <T[], R> combiner)
: base(n, combiner)
{
this.actual = actual;
}
internal AmbInnerConditionalSubscriber(AmbConditionalSubscription parent, IConditionalSubscriber <T> actual, int index)
{
this.parent = parent;
this.actual = actual;
this.index = index;
}
public GenerateConditionalSubscriber(IConditionalSubscriber <T> actual, S state, Func <S, ISignalEmitter <T>, S> generator, Action <S> stateDisposer) :
base(state, generator, stateDisposer)
{
this.actual = actual;
}
internal DoFinallyConditionalSubscriber(IConditionalSubscriber <T> actual, Action onFinally)
{
this.actual = actual;
this.onFinally = onFinally;
}
internal ConcatImmediateConditionalSubscriber(IConditionalSubscriber <R> actual, Func <T, IPublisher <R> > mapper, int prefetch)
: base(actual, mapper, prefetch)
{
}
internal RepeatFunctionConditionalSubscription(IConditionalSubscriber <T> actual, Func <T> func) : base(func)
{
this.actual = actual;
}
internal EnumerableConditionalSubscription(IConditionalSubscriber <T> actual, IEnumerator <T> enumerator) : base(enumerator)
{
this.actual = actual;
}
internal FilterConditionalSubscriber(IConditionalSubscriber <T> actual, Func <T, bool> predicate) : base(actual)
{
this.predicate = predicate;
}
internal SkipWhileConditionalSubscriber(IConditionalSubscriber <T> actual, Func <T, bool> predicate)
{
this.actual = actual;
this.predicate = predicate;
}
public MapErrorConditionalSubscriber(IConditionalSubscriber <T> actual, Func <Exception, Exception> errorMapper) : base(actual)
{
this.errorMapper = errorMapper;
}
internal MapTryConditionalSubscriber(IConditionalSubscriber <R> actual, Func <T, R> mapper, Func <long, Exception, ParallelFailureMode> handler)
{
this.actual = actual;
this.mapper = mapper;
this.handler = handler;
}
internal HalfSerializedConditionalSubscriber(IConditionalSubscriber <T> actual)
{
this.actual = actual;
}
