internal void Run() { IProcessor <T, T> w; IProcessor <T, T> x; lock (this) { if (stop) { return; } Interlocked.Increment(ref wip); w = window; if (Volatile.Read(ref cancelled)) { x = new UnicastProcessor <T>(capacityHint, this.InnerDone); window = x; } else { x = null; window = null; } } w?.OnComplete(); if (x != null) { Emit(x); } }
public void OnNext(T element) { var w = window; if (w == null) { int a = Volatile.Read(ref active); if (a != 0 && Interlocked.CompareExchange(ref active, a + 1, a) == a) { w = new UnicastProcessor <T>(size, OnTerminate); window = w; actual.OnNext(w); } } w.OnNext(element); int c = count + 1; if (c == size) { count = 0; w.OnComplete(); window = null; } else { count = c; } }
public void OnNext(T t) { var w = window; if (w == null) { Interlocked.Increment(ref wip); w = new UnicastProcessor <T>(size, this.InnerDone); window = w; actual.OnNext(w); } w.OnNext(t); int p = produced + 1; if (p == size) { w.OnComplete(); window = null; produced = 0; } else { produced = p; } }
public void ToEnumerable_Normal_Sync_Fused_Offline() { var up = new UnicastProcessor <int>(); List <int> expected = new List <int>(); for (int i = 1; i <= 5; i++) { expected.Add(i); up.OnNext(i); } up.OnComplete(); var ie = up.ToEnumerable(); List <int> list = new List <int>(); foreach (var i in ie) { list.Add(i); } Assert.AreEqual(5, list.Count); Assert.AreEqual(expected, list); }
public void Take_Exact_Number_Async_Fused() { var up = new UnicastProcessor <int>(); up.OnNext(1, 2, 3, 4, 5); up.Take(5).Test(fusionMode: FuseableHelper.ASYNC) .AssertResult(1, 2, 3, 4, 5); }
public void UnicastProcessor_Conditional_Offline() { var up = new UnicastProcessor <int>(); up.OnNext(1, 2, 3, 4, 5, 6); up.OnComplete(); var ts = up.Filter(v => true).Test(); ts.AssertResult(1, 2, 3, 4, 5, 6); }
internal WindowBoundarySubscriber(IFlowableSubscriber <IFlowable <T> > actual, int bufferSize) { this.actual = actual; this.active = 1; this.queue = new SpscLinkedArrayQueue <IFlowable <T> >(16); this.terminate = OnTerminate; this.bufferSize = bufferSize; this.buffer = new UnicastProcessor <T>(bufferSize, terminate); this.boundary = new BoundarySubscriber(this); queue.Offer(buffer); }
public void OnComplete() { var w = window; window = null; w?.OnComplete(); if (Volatile.Read(ref once) == 0) { actual.OnComplete(); } }
public void OnError(Exception cause) { var w = window; window = null; w?.OnError(cause); if (Volatile.Read(ref once) == 0) { actual.OnError(cause); } }
public void UnicastProcessor_Offline() { var up = new UnicastProcessor <int>(); up.OnNext(1, 2, 3, 4, 5, 6); up.OnComplete(); var ts = up.Test(); ts.AssertResult(1, 2, 3, 4, 5, 6); }
void StartWindow() { Interlocked.Increment(ref wip); IProcessor <T, T> w = new UnicastProcessor <T>(bufferSize, this.InnerDone); lock (this) { window = w; } Emit(w); }
public void OnNext(T element) { var q = queue; int idx = index; bool drain = false; if (idx == 0) { int a = Volatile.Read(ref active); if (a != 0 && Interlocked.CompareExchange(ref active, a + 1, a) == a) { var up = new UnicastProcessor <T>(size, OnTerminate); q.Offer(up); windows.Offer(up); drain = true; } } q.ForEach(element, CallNext); int c = count + 1; if (c == size) { count = c - skip; q.Poll(out var item); item.OnComplete(); } else { count = c; } if (++idx == skip) { index = 0; } else { index = idx; } if (drain) { Drain(); } }
public void Backpressure() { var pp = new UnicastProcessor <int>(); var ts1 = pp.Test(20); pp.OnNext(1); pp.OnNext(2); ts1.AssertValues(1, 2); pp.OnNext(3); ts1.AssertValues(1, 2, 3); }
public void OnComplete() { boundary.Cancel(); UnicastProcessor <T> b; lock (this) { b = buffer; if (b == null) { return; } buffer = null; } b.OnComplete(); Volatile.Write(ref done, true); Drain(); }
void BoundaryComplete() { SubscriptionHelper.Cancel(ref upstream); UnicastProcessor <T> b; lock (this) { b = buffer; if (b == null) { return; } buffer = null; } b.OnComplete(); Volatile.Write(ref done, true); Drain(); }
void StartWindow() { UnicastProcessor <T> up = new UnicastProcessor <T>(bufferSize, this.InnerDone); lock (this) { var queue = q; if (queue == null) { return; } Interlocked.Increment(ref wip); queue.Offer(up); } Emit(up); }
public override IPublisher <int> CreatePublisher(long elements) { var pp = new UnicastProcessor <int>(); Task.Factory.StartNew(() => { while (!pp.HasSubscribers) { Thread.Sleep(1); } for (int i = 0; i < elements; i++) { pp.OnNext(i); } pp.OnComplete(); }, TaskCreationOptions.LongRunning); return(pp); }
public void UnicastProcessor_Online_Fused_Scheduled() { for (int i = 0; i < 10000; i++) { var up = new UnicastProcessor <int>(); Task.Run(() => { up.OnNext(1, 2, 3, 4, 5, 6); up.OnComplete(); }); var ts = up.Test(fusionMode: FuseableHelper.ANY); ts .AwaitTerminalEvent(TimeSpan.FromSeconds(5)) .AssertResult(1, 2, 3, 4, 5, 6); } }
public void OnError(Exception cause) { boundary.Cancel(); UnicastProcessor <T> b; lock (this) { b = buffer; if (b == null) { return; } buffer = null; error = cause; } b.OnError(cause); Volatile.Write(ref done, true); Drain(); }
void BoundaryError(Exception cause) { SubscriptionHelper.Cancel(ref upstream); UnicastProcessor <T> b; lock (this) { b = buffer; if (b == null) { return; } buffer = null; error = cause; } b.OnError(cause); Volatile.Write(ref done, true); Drain(); }
public void UnicastProcessor_Online_Hidden_Scheduled() { for (int i = 0; i < 10000; i++) { var up = new UnicastProcessor <int>(); Task.Run(() => { up.OnNext(1, 2, 3, 4, 5, 6); up.OnComplete(); }); var ts = up.Hide().Test(); ts .AwaitTerminalEvent(TimeSpan.FromSeconds(5)) .AssertResult(1, 2, 3, 4, 5, 6); } }
public void OnNext(T t) { int i = index; if (i == 0 && !Volatile.Read(ref cancelled)) { Interlocked.Increment(ref wip); var b = new UnicastProcessor <T>(size, this.InnerDone); q.Offer(b); actual.OnNext(b); } i++; if (i == skip) { index = 0; } else { index = i; } q.ForEach(b => b.OnNext(t)); int p = produced + 1; if (p == size) { IProcessor <T, T> b; q.Poll(out b); b.OnComplete(); produced = size - skip; } else { produced = p; } }
public void Async() { var pp = new UnicastProcessor <int>(); Task.Factory.StartNew(() => { while (!pp.HasSubscribers) { Thread.Sleep(10); } for (int i = 0; i < 5; i++) { pp.OnNext(i); } pp.OnComplete(); }, TaskCreationOptions.LongRunning); pp.Test().AwaitDone(TimeSpan.FromSeconds(5)) .AssertResult(0, 1, 2, 3, 4); }
public void Normal() { var dp = new UnicastProcessor <int>(); Assert.IsFalse(dp.HasSubscribers); var ts = dp.Test(); Assert.IsTrue(dp.HasSubscribers); dp.OnNext(1); dp.OnNext(2); dp.OnNext(3); dp.OnNext(4); ts.AssertValues(1, 2, 3, 4); dp.OnComplete(); ts.AssertResult(1, 2, 3, 4); }
void BoundaryNext() { int a = Volatile.Read(ref active); if (a != 0 && Interlocked.CompareExchange(ref active, a + 1, a) == a) { var u = new UnicastProcessor <T>(bufferSize, terminate); UnicastProcessor <T> b; lock (this) { b = buffer; if (b == null) { return; } buffer = u; queue.Offer(u); } b.OnComplete(); Drain(); } }
public void UnicastProcessor_Online_Fused_Scheduled_5() { for (int i = 0; i < 10000; i++) { var up = new UnicastProcessor <int>(); var ts = new TestSubscriber <int>(fusionMode: FuseableHelper.ANY); int[] wait = { 2 }; Task.Run(() => { up.OnNext(1, 2); up.OnNext(3, 4); up.OnNext(5, 6); Interlocked.Decrement(ref wait[0]); while (Volatile.Read(ref wait[0]) != 0) { ; } up.OnComplete(); }); Interlocked.Decrement(ref wait[0]); while (Volatile.Read(ref wait[0]) != 0) { ; } up.Subscribe(ts); ts .AwaitTerminalEvent(TimeSpan.FromSeconds(5)) .AssertResult(1, 2, 3, 4, 5, 6); } }