TakeUntilMainSubscriber(CoreSubscriber<? super T> actual) { this.actual = Operators.serialize(actual); }
/** * Create a {@link FluxProcessor} that safely gates multi-threaded producer * {@link Subscriber#onNext(Object)}. * * @return a serializing {@link FluxProcessor} */ public final FluxProcessor<IN, OUT> serialize() { return new DelegateProcessor<>(this, Operators.serialize(this)); }
SkipUntilMainSubscriber(CoreSubscriber<? super T> actual) { this.actual = Operators.serialize(actual); this.ctx = actual.currentContext(); }
@Override public void subscribe(CoreSubscriber<? super C> actual) { source.subscribe(new BufferTimeoutSubscriber<>(Operators.serialize(actual), batchSize, timespan, timer.createWorker(), bufferSupplier)); }
@Override public void subscribe(CoreSubscriber<? super R> actual) { CoreSubscriber<R> serial = Operators.serialize(actual); WithLatestFromSubscriber<T, U, R> main = new WithLatestFromSubscriber<>(serial, combiner); WithLatestFromOtherSubscriber<U> secondary = new WithLatestFromOtherSubscriber<>(main); other.subscribe(secondary); source.subscribe(main); }
static <T> void subscribe(CoreSubscriber<? super T> s, Function<? super Flux<Throwable>, ? extends Publisher<?>> whenSourceFactory, Publisher<? extends T> source) { RetryWhenOtherSubscriber other = new RetryWhenOtherSubscriber(); Subscriber<Throwable> signaller = Operators.serialize(other.completionSignal); signaller.onSubscribe(Operators.emptySubscription()); CoreSubscriber<T> serial = Operators.serialize(s); RetryWhenMainSubscriber<T> main = new RetryWhenMainSubscriber<>(serial, signaller, source); other.main = main; serial.onSubscribe(main); Publisher<?> p; try { p = Objects.requireNonNull(whenSourceFactory.apply(other), "The whenSourceFactory returned a null Publisher"); } catch (Throwable e) { s.onError(Operators.onOperatorError(e, s.currentContext())); return; } p.subscribe(other); if (!main.cancelled) { source.subscribe(main); } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { RepeatWhenOtherSubscriber other = new RepeatWhenOtherSubscriber(); Subscriber<Long> signaller = Operators.serialize(other.completionSignal); signaller.onSubscribe(Operators.emptySubscription()); CoreSubscriber<T> serial = Operators.serialize(actual); RepeatWhenMainSubscriber<T> main = new RepeatWhenMainSubscriber<>(serial, signaller, source); other.main = main; serial.onSubscribe(main); Publisher<?> p; try { p = Objects.requireNonNull(whenSourceFactory.apply(other), "The whenSourceFactory returned a null Publisher"); } catch (Throwable e) { actual.onError(Operators.onOperatorError(e, actual.currentContext())); return; } p.subscribe(other); if (!main.cancelled) { source.subscribe(main); } }
@Override public void subscribe(CoreSubscriber<? super C> actual) { C buffer; try { buffer = Objects.requireNonNull(bufferSupplier.get(), "The bufferSupplier returned a null buffer"); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } BufferBoundaryMain<T, U, C> parent = new BufferBoundaryMain<>( source instanceof FluxInterval ? actual : Operators.serialize(actual), buffer, bufferSupplier); actual.onSubscribe(parent); other.subscribe(parent.other); source.subscribe(parent); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { CoreSubscriber<T> serial = Operators.serialize(actual); SampleMainSubscriber<T> main = new SampleMainSubscriber<>(serial); actual.onSubscribe(main); other.subscribe(new SampleOther<>(main)); source.subscribe(main); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { CoreSubscriber<T> serial = Operators.serialize(actual); TimeoutMainSubscriber<T, V> main = new TimeoutMainSubscriber<>(serial, itemTimeout, other, timeoutDescription); serial.onSubscribe(main); TimeoutTimeoutSubscriber ts = new TimeoutTimeoutSubscriber(main, 0L); main.setTimeout(ts); firstTimeout.subscribe(ts); source.subscribe(main); }
@Override @SuppressWarnings("unchecked") public void subscribe(CoreSubscriber<? super T> actual) { CoreSubscriber<T> serial = Operators.serialize(actual); FluxTimeout.TimeoutMainSubscriber<T, V> main = new FluxTimeout.TimeoutMainSubscriber<>(serial, NEVER, other, addNameToTimeoutDescription(source, timeoutDescription)); serial.onSubscribe(main); FluxTimeout.TimeoutTimeoutSubscriber ts = new FluxTimeout.TimeoutTimeoutSubscriber(main, 0L); main.setTimeout(ts); firstTimeout.subscribe(ts); source.subscribe(main); } }
TakeUntilMainSubscriber(CoreSubscriber<? super T> actual) { this.actual = Operators.serialize(actual); }
/** * Create a {@link FluxProcessor} that safely gates multi-threaded producer * {@link Subscriber#onNext(Object)}. * * @return a serializing {@link FluxProcessor} */ public final FluxProcessor<IN, OUT> serialize() { return new DelegateProcessor<>(this, Operators.serialize(this)); }
SkipUntilMainSubscriber(CoreSubscriber<? super T> actual) { this.actual = Operators.serialize(actual); this.ctx = actual.currentContext(); }
@Override public void subscribe(CoreSubscriber<? super C> actual) { source.subscribe(new BufferTimeoutSubscriber<>(Operators.serialize(actual), batchSize, timespan, timer.createWorker(), bufferSupplier)); }
@Override public void subscribe(CoreSubscriber<? super R> actual) { CoreSubscriber<R> serial = Operators.serialize(actual); WithLatestFromSubscriber<T, U, R> main = new WithLatestFromSubscriber<>(serial, combiner); WithLatestFromOtherSubscriber<U> secondary = new WithLatestFromOtherSubscriber<>(main); other.subscribe(secondary); source.subscribe(main); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { CoreSubscriber<T> serial = Operators.serialize(actual); SampleMainSubscriber<T> main = new SampleMainSubscriber<>(serial); actual.onSubscribe(main); other.subscribe(new SampleOther<>(main)); source.subscribe(main); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { CoreSubscriber<T> serial = Operators.serialize(actual); TimeoutMainSubscriber<T, V> main = new TimeoutMainSubscriber<>(serial, itemTimeout, other, timeoutDescription); serial.onSubscribe(main); TimeoutTimeoutSubscriber ts = new TimeoutTimeoutSubscriber(main, 0L); main.setTimeout(ts); firstTimeout.subscribe(ts); source.subscribe(main); }
@Override @SuppressWarnings("unchecked") public void subscribe(CoreSubscriber<? super T> actual) { CoreSubscriber<T> serial = Operators.serialize(actual); FluxTimeout.TimeoutMainSubscriber<T, V> main = new FluxTimeout.TimeoutMainSubscriber<>(serial, NEVER, other, addNameToTimeoutDescription(source, timeoutDescription)); serial.onSubscribe(main); FluxTimeout.TimeoutTimeoutSubscriber ts = new FluxTimeout.TimeoutTimeoutSubscriber(main, 0L); main.setTimeout(ts); firstTimeout.subscribe(ts); source.subscribe(main); } }