@Override public void onNext(T value) { if (sourceMode == QueueDisposable.NONE) { queue.offer(value); } drain(); }
@Override public void onNext(T t) { if (done) { return; } if (sourceMode != QueueDisposable.ASYNC) { queue.offer(t); } schedule(); }
@Override public void onNext(R t) { if (index == parent.unique) { if (t != null) { queue.offer(t); } parent.drain(); } }
@Override public void onNext(T t) { if (t != null) { queue.offer(t); } drain(); }
@Override public void onNext(T t) { if (done) { return; } if (fusionMode == QueueDisposable.NONE) { queue.offer(t); } drain(); }
@Override public void onNext(T value) { if (sourceMode == QueueDisposable.NONE) { queue.offer(value); } drain(); }
@Override public void onNext(T t) { if (sourceMode != QueueSubscription.ASYNC) { queue.offer(t); } parent.drain(); }
@Override public void innerNext(InnerQueuedObserver<R> inner, R value) { inner.queue().offer(value); drain(); }
@Override public final void onNext(T t) { if (sourceMode != QueueSubscription.ASYNC) { if (!queue.offer(t)) { upstream.cancel(); onError(new IllegalStateException("Queue full?!")); return; } } drain(); }
@Override public void onNext(R t) { SwitchMapSubscriber<T, R> p = parent; if (index == p.unique) { if (fusionMode == QueueSubscription.NONE && !queue.offer(t)) { onError(new MissingBackpressureException("Queue full?!")); return; } p.drain(); } }
@Override public void onNext(T t) { if (done) { return; } if (fusionMode == NONE && !queue.offer(t)) { onError(new MissingBackpressureException("Queue is full?!")); return; } drain(); }
@Override public void onNext(T t) { if (sourceMode == QueueSubscription.NONE) { if (!queue.offer(t)) { onError(new MissingBackpressureException()); return; } } parent.drain(); }
@Override public void onNext(CompletableSource t) { if (sourceFused == QueueSubscription.NONE) { if (!queue.offer(t)) { onError(new MissingBackpressureException()); return; } } drain(); }
@Override public void onNext(T t) { if (done) { return; } if (sourceMode == QueueSubscription.NONE && !queue.offer(t)) { upstream.get().cancel(); onError(new MissingBackpressureException()); return; } drain(); }
@Override public void onNext(T t) { // we expect upstream to honor backpressure requests if (sourceMode == QueueSubscription.NONE && !queue.offer(t)) { onError(new MissingBackpressureException("Prefetch queue is full?!")); return; } // since many things can happen concurrently, we have a common dispatch // loop to act on the current state serially dispatch(); }
/** * Assert that the offer methods throw UnsupportedOperationExcetpion. * @param q the queue implementation */ public static void assertNoOffer(SimpleQueue<?> q) { try { q.offer(null); fail("Should have thrown!"); } catch (UnsupportedOperationException ex) { // expected } try { q.offer(null, null); fail("Should have thrown!"); } catch (UnsupportedOperationException ex) { // expected } }
@Override public void onNext(T t) { if (sourceMode == QueueSubscription.NONE) { if (!queue.offer(t)) { upstream.cancel(); onError(new MissingBackpressureException("Queue is full?")); return; } } drain(); }
@Override public void onNext(T t) { if (once.get()) { return; } if (fusionMode == QueueSubscription.NONE) { ObjectHelper.requireNonNull(t, "onNext called with null. Null values are generally not allowed in 2.x operators and sources."); if (!queue.offer(t)) { SubscriptionHelper.cancel(upstream); onError(new MissingBackpressureException()); return; } } drain(); }
@Override public final void onNext(T t) { if (done) { return; } if (sourceMode == ASYNC) { trySchedule(); return; } if (!queue.offer(t)) { upstream.cancel(); error = new MissingBackpressureException("Queue is full?!"); done = true; } trySchedule(); }
@Override public void innerNext(InnerQueuedSubscriber<R> inner, R value) { if (inner.queue().offer(value)) { drain(); } else { inner.cancel(); innerError(inner, new MissingBackpressureException()); } }