@Test public void latestSinkToString() { StepVerifier.create(Flux.create(sink -> { sink.next(sink.toString()); if (sink instanceof SerializedSink) { sink.next(((SerializedSink) sink).sink.toString()); sink.complete(); } else { sink.error(new IllegalArgumentException("expected SerializedSink")); } }, OverflowStrategy.LATEST)) .expectNext("FluxSink(LATEST)") .expectNext("FluxSink(LATEST)") .verifyComplete(); } }
void drainLoop() { Context ctx = sink.currentContext(); BaseSink<T> e = sink; Queue<T> q = mpscQueue; if (e.isCancelled()) { Operators.onDiscardQueueWithClear(q, ctx, null); return; Operators.onDiscardQueueWithClear(q, ctx, null); e.error(Exceptions.terminate(ERROR, this)); return; e.complete(); return; e.next(v); Operators.onOperatorError(sink, ex, v, sink.currentContext());
onSubscribe(s); if(s.isCancelled() || (isSerialized() && getBufferSize() == Integer.MAX_VALUE)){ return s;
void drainLoop() { Context ctx = sink.currentContext(); BaseSink<T> e = sink; Queue<T> q = mpscQueue; if (e.isCancelled()) { Operators.onDiscardQueueWithClear(q, ctx, null); return; Operators.onDiscardQueueWithClear(q, ctx, null); e.error(Exceptions.terminate(ERROR, this)); return; e.complete(); return; e.next(v); Operators.onOperatorError(sink, ex, v, sink.currentContext());
@Override public FluxSink<T> next(T t) { Objects.requireNonNull(t, "t is null in sink.next(t)"); if (sink.isCancelled() || done) { Operators.onNextDropped(t, sink.currentContext()); return this; } if (WIP.get(this) == 0 && WIP.compareAndSet(this, 0, 1)) { try { sink.next(t); } catch (Throwable ex) { Operators.onOperatorError(sink, ex, t, sink.currentContext()); } if (WIP.decrementAndGet(this) == 0) { return this; } } else { this.mpscQueue.offer(t); if (WIP.getAndIncrement(this) != 0) { return this; } } drainLoop(); return this; }
@Override public void error(Throwable t) { Objects.requireNonNull(t, "t is null in sink.error(t)"); if (sink.isCancelled() || done) { Operators.onOperatorError(t, sink.currentContext()); return; } if (Exceptions.addThrowable(ERROR, this, t)) { done = true; drain(); } else { Operators.onOperatorError(t, sink.currentContext()); } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { BaseSink<T> sink = createSink(actual, backpressure); actual.onSubscribe(sink); try { source.accept( createMode == CreateMode.PUSH_PULL ? new SerializedSink<>(sink) : sink); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); sink.error(Operators.onOperatorError(ex, actual.currentContext())); } }
@Override public boolean isCancelled() { return sink.isCancelled(); }
@Override public Context currentContext() { return sink.currentContext(); }
@Override public void error(Throwable e) { if (isCancelled()) { Operators.onOperatorError(e, ctx); return; } try { actual.onError(e); } finally { disposeResource(false); } }
@Override public void complete() { if (sink.isCancelled() || done) { return; } done = true; drain(); }
@Override public FluxSink<T> onRequest(LongConsumer consumer) { sink.onRequest(consumer, consumer, sink.requested); return this; }
@Override public String toString() { return sink.toString(); } }
@Override public FluxSink<T> onCancel(Disposable d) { sink.onCancel(d); return this; }
@Override public String toString() { return baseSink.toString(); } }
@Override public FluxSink<T> onRequest(LongConsumer consumer) { Objects.requireNonNull(consumer, "onRequest"); onRequest(consumer, n -> { }, Long.MAX_VALUE); return this; }
@Override public final void request(long n) { if (Operators.validate(n)) { Operators.addCap(REQUESTED, this, n); LongConsumer consumer = requestConsumer; if (n > 0 && consumer != null && !isCancelled()) { consumer.accept(n); } onRequestedFromDownstream(); } }