public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
s.Request(parent.bufferSize);
}
}
public void OtherSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref other, s))
{
s.Request(long.MaxValue);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
processor.OnSubscribe(this);
}
}
internal void OtherSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref z, s))
{
s.Request(long.MaxValue);
}
}
/// <summary>
/// Invoked after calling IPublisher.Subscribe(ISubscriber).
/// No data will start flowing until ISubscription.Request(long)
/// is invoked.
/// It is the responsibility of this ISubscriber instance to call
/// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted.
/// The IPublisher will send notifications only in response to
/// Reactive.Streams.ISubscription.Request(System.Int64).
/// </summary>
/// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param>
public void OnSubscribe(ISubscription subscription)
{
if (SubscriptionHelper.SetOnce(ref upstream, subscription, false))
{
if (subscription is IQueueSubscription <T> qs)
{
int m = qs.RequestFusion(FusionSupport.ANY);
if (m == FusionSupport.SYNC)
{
fusionMode = m;
Volatile.Write(ref queue, qs);
Volatile.Write(ref done, true);
Drain();
return;
}
if (m == FusionSupport.ASYNC)
{
fusionMode = m;
Volatile.Write(ref queue, qs);
subscription.Request(bufferSize);
return;
}
}
Volatile.Write(ref queue, new SpscArrayQueue <T>(bufferSize));
subscription.Request(bufferSize);
}
}
/// <summary>
/// Initializes the PublishProcessor with the default buffer size and and
/// empty ISubscription; this allows using the PublishProcessor without
/// subscribing it to an IPublisher.
/// </summary>
public void Start()
{
if (SubscriptionHelper.SetOnce(ref upstream, EmptySubscription <T> .Instance))
{
Volatile.Write(ref queue, new SpscArrayQueue <T>(bufferSize));
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
s.Request(prefetch);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
var qs = s as IQueueSubscription <T>;
if (qs != null)
{
int m = qs.RequestFusion(FuseableHelper.ANY);
if (m == FuseableHelper.SYNC)
{
fusionMode = m;
Volatile.Write(ref queue, qs);
Volatile.Write(ref done, true);
parent.InnerComplete();
return;
}
if (m == FuseableHelper.ASYNC)
{
fusionMode = m;
Volatile.Write(ref queue, qs);
}
}
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
}
}
public void OnSubscribe(ISubscription subscription)
{
if (SubscriptionHelper.SetOnce(ref upstream, subscription))
{
subscription.Request(long.MaxValue);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
s.Request(long.MaxValue);
}
}
public void OnSubscribe(ISubscription subscription)
{
if (SubscriptionHelper.SetOnce(ref upstream, subscription))
{
subscription.Request(bufferSize);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
actual.OnSubscribe(this);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
var qs = s as IQueueSubscription <R>;
if (qs != null)
{
int m = qs.RequestFusion(FuseableHelper.ANY);
if (m == FuseableHelper.SYNC)
{
fusionMode = m;
queue = qs;
Volatile.Write(ref done, true);
parent.Drain();
}
else
if (m == FuseableHelper.ASYNC)
{
fusionMode = m;
queue = qs;
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
return;
}
}
queue = QueueDrainHelper.CreateQueue <R>(prefetch);
s.Request(prefetch < 0 ? long.MaxValue : prefetch);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref main, s))
{
actual.OnSubscribe(this);
s.Request(long.MaxValue);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
worker.SchedulePeriodically(StartWindow, timeskip, timeskip);
worker.SchedulePeriodically(EndWindow, timespan, timespan);
s.Request(long.MaxValue);
}
}
/// <summary>
/// Atomically set the new ISubscription once on the current field and request
/// any accumulated value.
/// </summary>
/// <param name="current">The current ISubscription field</param>
/// <param name="requested">The requested amount field</param>
/// <param name="s">The new ISubscription to set once</param>
public static void DeferredSetOnce(ref ISubscription current, ref long requested, ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref current, s))
{
long r = Interlocked.Exchange(ref requested, 0L);
if (r != 0L)
{
s.Request(r);
}
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
Emit(window);
Set(scheduler.SchedulePeriodicallyDirect(this.Run, time, time));
s.Request(long.MaxValue);
}
}
public void Set(int index, ISubscription s)
{
if (index == 0)
{
SubscriptionHelper.SetOnce(ref first, s);
}
else
{
SubscriptionHelper.SetOnce(ref second, s);
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.other, s))
{
s.Request(long.MaxValue);
}
else
{
s.Cancel();
OnSubscribeHelper.ReportSubscriptionSet();
}
}
/// <inheritdoc/>
public void OnSubscribe(ISubscription s)
{
subscriptions++;
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
var qs = s as IQueueSubscription <T>;
this.qs = qs;
if (qs != null)
{
if (requestFusionMode != FuseableHelper.NONE)
{
int m = qs.RequestFusion(requestFusionMode);
establishedFusionMode = m;
if (m == FuseableHelper.SYNC)
{
try
{
try
{
T v;
while (qs.Poll(out v))
{
values.Add(v);
}
completions++;
Volatile.Write(ref valueCount, values.Count);
Volatile.Write(ref lastTimestamp, DateTimeOffset.UtcNow.UtcMillis());
}
catch (Exception ex)
{
errors.Add(ex);
}
}
finally
{
cde.Signal();
}
return;
}
}
}
long r = Interlocked.Exchange(ref requested, 0L);
if (r != 0L)
{
s.Request(r);
}
}
}
/// <summary>
/// Invoked after calling IPublisher.Subscribe(ISubscriber).
/// No data will start flowing until ISubscription.Request(long)
/// is invoked.
/// It is the responsibility of this ISubscriber instance to call
/// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted.
/// The IPublisher will send notifications only in response to
/// Reactive.Streams.ISubscription.Request(System.Int64).
/// </summary>
/// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param>
public void OnSubscribe(ISubscription subscription)
{
if (SubscriptionHelper.SetOnce(ref upstream, subscription, crash: false))
{
if (manager.HasTerminated)
{
subscription.Cancel();
}
else
{
subscription.Request(long.MaxValue);
}
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
if (maxConcurrency == int.MaxValue)
{
s.Request(long.MaxValue);
}
else
{
s.Request(maxConcurrency);
}
}
}
/// <summary>
/// Invoked after calling IPublisher.Subscribe(ISubscriber).
/// No data will start flowing until ISubscription.Request(long)
/// is invoked.
/// It is the responsibility of this ISubscriber instance to call
/// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted.
/// The IPublisher will send notifications only in response to
/// Reactive.Streams.ISubscription.Request(System.Int64).
/// </summary>
/// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param>
public void OnSubscribe(ISubscription subscription)
{
if (SubscriptionHelper.SetOnce(ref upstream, subscription, false))
{
if (Volatile.Read(ref done) || Volatile.Read(ref cancelled))
{
subscription.Cancel();
}
else
{
subscription.Request(long.MaxValue);
}
}
}
/// <summary>
/// Invoked after calling IPublisher.Subscribe(ISubscriber).
/// No data will start flowing until ISubscription.Request(long)
/// is invoked.
/// It is the responsibility of this ISubscriber instance to call
/// Reactive.Streams.ISubscription.Request(System.Int64) whenever more data is wanted.
/// The IPublisher will send notifications only in response to
/// Reactive.Streams.ISubscription.Request(System.Int64).
/// </summary>
/// <param name="subscription">ISubscription that allows requesting data via ISubscription.Request(long)</param>
public void OnSubscribe(ISubscription subscription)
{
if (SubscriptionHelper.SetOnce(ref upstream, subscription, false))
{
if (Volatile.Read(ref subscribers) != Terminated)
{
subscription.Request(long.MaxValue);
}
else
{
subscription.Cancel();
}
}
}
public void OnSubscribe(ISubscription s)
{
if (SubscriptionHelper.SetOnce(ref this.s, s))
{
try
{
onSubscribeCall(s);
}
catch (Exception e)
{
done = true;
s.Cancel();
RxAdvancedFlowPlugins.OnError(e);
}
}
}
public void OnSubscribe(ISubscription s)
{
SubscriptionHelper.SetOnce(ref this.s, s);
}
internal void SetOther(ISubscription s)
{
SubscriptionHelper.SetOnce(ref other, s);
}
