@Override public int requestFusion(int mode) { QueueDisposable<T> qd = this.qd; if (qd != null && (mode & BOUNDARY) == 0) { int m = qd.requestFusion(mode); if (m != NONE) { syncFused = m == SYNC; } return m; } return NONE; }
/** * Calls the upstream's QueueDisposable.requestFusion with the mode and * saves the established mode in {@link #sourceMode} if that mode doesn't * have the {@link QueueDisposable#BOUNDARY} flag set. * <p> * If the upstream doesn't support fusion ({@link #qd} is null), the method * returns {@link QueueDisposable#NONE}. * @param mode the fusion mode requested * @return the established fusion mode */ protected final int transitiveBoundaryFusion(int mode) { QueueDisposable<T> qd = this.qd; if (qd != null) { if ((mode & BOUNDARY) == 0) { int m = qd.requestFusion(mode); if (m != NONE) { sourceMode = m; } return m; } } return NONE; }
@Override public int requestFusion(int mode) { QueueDisposable<T> qd = this.qd; if (qd != null && (mode & BOUNDARY) == 0) { int m = qd.requestFusion(mode); if (m != NONE) { syncFused = m == SYNC; } return m; } return NONE; }
@Override public int requestFusion(int mode) { QueueDisposable<T> fs = qd; if (fs != null) { return fs.requestFusion(mode & ~BOUNDARY); } return NONE; }
@Override public void onSubscribe(Disposable d) { this.upstream = d; ((QueueDisposable<?>)d).requestFusion(QueueFuseable.ANY); }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.setOnce(this, d)) { if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<U> qd = (QueueDisposable<U>) d; int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY); if (m == QueueDisposable.SYNC) { fusionMode = m; queue = qd; done = true; parent.drain(); return; } if (m == QueueDisposable.ASYNC) { fusionMode = m; queue = qd; } } } }
@SuppressWarnings("unchecked") @Override public void onSubscribe(Disposable d) { this.d = (QueueDisposable<Integer>)d; to.onSubscribe(d); this.d.requestFusion(QueueFuseable.ANY); }
@SuppressWarnings("unchecked") @Override public void onSubscribe(Disposable d) { this.d = (QueueDisposable<Integer>)d; to.onSubscribe(d); this.d.requestFusion(QueueFuseable.ANY); }
@SuppressWarnings("unchecked") @Override public void onSubscribe(Disposable d) { this.d = (QueueDisposable<Integer>)d; to.onSubscribe(d); this.d.requestFusion(QueueFuseable.ANY); }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.setOnce(this, d)) { if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<R> qd = (QueueDisposable<R>) d; int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY); if (m == QueueDisposable.SYNC) { queue = qd; done = true; parent.drain(); return; } if (m == QueueDisposable.ASYNC) { queue = qd; return; } } queue = new SpscLinkedArrayQueue<R>(bufferSize); } }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.setOnce(this, d)) { if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<T> qd = (QueueDisposable<T>) d; int m = qd.requestFusion(QueueDisposable.ANY); if (m == QueueSubscription.SYNC) { fusionMode = m; queue = qd; done = true; parent.innerComplete(this); return; } if (m == QueueDisposable.ASYNC) { fusionMode = m; queue = qd; return; } } queue = QueueDrainHelper.createQueue(-prefetch); } }
@Override public void onSubscribe(Disposable d) { try { if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<Object> qd = (QueueDisposable<Object>) d; state[0] = true; int m = qd.requestFusion(QueueFuseable.ANY); if (m != QueueFuseable.NONE) { state[1] = true; state[2] = qd.isEmpty(); qd.clear(); state[3] = qd.isEmpty(); } } cdl.countDown(); } finally { d.dispose(); } }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.validate(upstream, d)) { this.upstream = d; if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<T> qd = (QueueDisposable<T>) d; int m = qd.requestFusion(QueueDisposable.ANY); if (m == QueueDisposable.SYNC) { queue = qd; done = true; downstream.onSubscribe(this); drain(); return; } if (m == QueueDisposable.ASYNC) { queue = qd; downstream.onSubscribe(this); return; } } queue = new SpscLinkedArrayQueue<T>(prefetch); downstream.onSubscribe(this); } }
@SuppressWarnings("unchecked") @Override public void onSubscribe(Disposable d) { if (DisposableHelper.validate(this.upstream, d)) { this.upstream = d; if (d instanceof QueueDisposable) { QueueDisposable<T> qd = (QueueDisposable<T>) d; int m = qd.requestFusion(QueueDisposable.ANY); if (m == QueueDisposable.SYNC) { sourceMode = m; queue = qd; done = true; downstream.onSubscribe(this); drain(); return; } if (m == QueueDisposable.ASYNC) { sourceMode = m; queue = qd; downstream.onSubscribe(this); return; } } queue = new SpscLinkedArrayQueue<T>(prefetch); downstream.onSubscribe(this); } }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.validate(this.upstream, d)) { this.upstream = d; if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<T> qd = (QueueDisposable<T>) d; int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY); if (m == QueueDisposable.SYNC) { sourceMode = m; queue = qd; done = true; downstream.onSubscribe(this); schedule(); return; } if (m == QueueDisposable.ASYNC) { sourceMode = m; queue = qd; downstream.onSubscribe(this); return; } } queue = new SpscLinkedArrayQueue<T>(bufferSize); downstream.onSubscribe(this); } }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.validate(this.upstream, d)) { this.upstream = d; if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<T> qd = (QueueDisposable<T>) d; int m = qd.requestFusion(QueueDisposable.ANY); if (m == QueueDisposable.SYNC) { fusionMode = m; queue = qd; done = true; downstream.onSubscribe(this); drain(); return; } if (m == QueueDisposable.ASYNC) { fusionMode = m; queue = qd; downstream.onSubscribe(this); return; } } queue = new SpscLinkedArrayQueue<T>(bufferSize); downstream.onSubscribe(this); } }
@Override public void onSubscribe(Disposable d) { if (DisposableHelper.validate(this.upstream, d)) { this.upstream = d; if (d instanceof QueueDisposable) { @SuppressWarnings("unchecked") QueueDisposable<T> qd = (QueueDisposable<T>) d; int m = qd.requestFusion(QueueDisposable.ANY); if (m == QueueDisposable.SYNC) { sourceMode = m; queue = qd; done = true; downstream.onSubscribe(this); drain(); return; } if (m == QueueDisposable.ASYNC) { sourceMode = m; queue = qd; downstream.onSubscribe(this); return; } } queue = new SpscLinkedArrayQueue<T>(bufferSize); downstream.onSubscribe(this); } }
@Override public void onSubscribe(Disposable d) { @SuppressWarnings("unchecked") QueueDisposable<Integer> qd = (QueueDisposable<Integer>)d; qd.requestFusion(QueueFuseable.ANY); try { assertEquals(1, qd.poll().intValue()); } catch (Throwable ex) { fail(ex.toString()); } qd.clear(); try { assertNull(qd.poll()); } catch (Throwable ex) { fail(ex.toString()); } }
@Override public void onSubscribe(Disposable d) { @SuppressWarnings("unchecked") QueueDisposable<Integer> qd = (QueueDisposable<Integer>)d; qd.requestFusion(QueueFuseable.ANY); assertFalse(qd.isEmpty()); try { assertEquals(1, qd.poll().intValue()); } catch (Throwable ex) { throw new RuntimeException(ex); } assertFalse(qd.isEmpty()); qd.clear(); assertTrue(qd.isEmpty()); qd.dispose(); }
@Override public void onSubscribe(Disposable d) { @SuppressWarnings("unchecked") QueueDisposable<Integer> qd = (QueueDisposable<Integer>)d; qd.requestFusion(QueueFuseable.ANY); assertFalse(qd.isEmpty()); assertFalse(qd.isDisposed()); try { assertEquals(1, qd.poll().intValue()); } catch (Throwable ex) { throw new RuntimeException(ex); } assertFalse(qd.isEmpty()); qd.clear(); assertTrue(qd.isEmpty()); qd.dispose(); assertTrue(qd.isDisposed()); }