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); }