@Override public void subscribe(CoreSubscriber<? super Object> actual) { Operators.complete(actual); }
@Override public void subscribe(CoreSubscriber<? super Object> actual) { Operators.complete(actual); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { try { run.run(); } catch (Throwable ex) { Operators.error(actual, Operators.onOperatorError(ex, actual.currentContext())); return; } Operators.complete(actual); }
@SuppressWarnings("unchecked") @Override public void onSubscribe(Subscription s) { if (Operators.validate(this.qs, s)) { if (n == 0) { s.cancel(); done = true; Operators.complete(actual); } else { this.qs = (QueueSubscription<T>) s; actual.onSubscribe(this); } } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { if (state == STATE_INIT && STATE.compareAndSet(this, STATE_INIT, STATE_SUBSCRIBED_ONCE)) { if (first == null && done) { if (throwable != null) { Operators.error(actual, throwable); } else { Operators.complete(actual); } return; } INNER.lazySet(this, actual); actual.onSubscribe(this); } else { Operators.error(actual, new IllegalStateException("FluxSwitchOnFirst allows only one Subscriber")); } }
@Override public void onSubscribe(Subscription s) { if (Operators.validate(this.s, s)) { if (n == 0) { s.cancel(); done = true; Operators.complete(actual); } else { this.s = s; actual.onSubscribe(this); } } }
@Override public void onComplete() { if (main == null) { if (MAIN.compareAndSet(this, null, Operators.cancelledSubscription())) { cancelOther(); Operators.complete(actual); return; } } cancel(); actual.onComplete(); } }
@Override public void onSubscribe(Subscription s) { if (Operators.validate(this.s, s)) { if (n == 0) { s.cancel(); done = true; Operators.complete(actual); } else { this.s = s; actual.onSubscribe(this); } } }
void otherComplete() { if (otherValue == null) { if (main == null) { if (MAIN.compareAndSet(this, null, Operators.cancelledSubscription())) { cancelMain(); Operators.complete(actual); return; } } cancelMain(); actual.onComplete(); } } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { if (state == STATE_INIT && STATE.compareAndSet(this, STATE_INIT, STATE_SUBSCRIBED_ONCE)) { if (first == null && done) { if (throwable != null) { Operators.error(actual, throwable); } else { Operators.complete(actual); } return; } INNER.lazySet(this, Operators.toConditionalSubscriber(actual)); actual.onSubscribe(this); } else { Operators.error(actual, new IllegalStateException("FluxSwitchOnFirst allows only one Subscriber")); } }
Operators.complete(actual); return;
@SuppressWarnings("unchecked") public static <T> void subscribe(CoreSubscriber<? super T> s, T[] array) { if (array.length == 0) { Operators.complete(s); return; } if (s instanceof ConditionalSubscriber) { s.onSubscribe(new ArrayConditionalSubscription<>((ConditionalSubscriber<? super T>) s, array)); } else { s.onSubscribe(new ArraySubscription<>(s, array)); } }
@Override public void subscribe(CoreSubscriber<? super R> actual) { Iterator<? extends U> it; try { it = Objects.requireNonNull(other.iterator(), "The other iterable produced a null iterator"); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } boolean b; try { b = it.hasNext(); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } if (!b) { Operators.complete(actual); return; } source.subscribe(new ZipSubscriber<>(actual, it, zipper)); }
@Override @SuppressWarnings("unchecked") public void subscribe(CoreSubscriber<? super T> actual) { if (resourceSupplier instanceof Callable) { try { Callable<S> resourceCallable = (Callable<S>) resourceSupplier; S resource = resourceCallable.call(); if (resource == null) { Operators.complete(actual); } else { final Mono<? extends T> p = deriveMonoFromResource(resource, resourceClosure); final UsingWhenSubscriber<? super T, S> subscriber = prepareSubscriberForResource(resource, actual, asyncComplete, asyncError, asyncCancel, null); p.subscribe(subscriber); } } catch (Throwable e) { Operators.error(actual, e); } return; } resourceSupplier.subscribe(new ResourceSubscriber(actual, resourceClosure, asyncComplete, asyncError, asyncCancel, resourceSupplier instanceof Mono)); }
@Override @SuppressWarnings("unchecked") public void subscribe(CoreSubscriber<? super Integer> actual) { long st = start; long en = end; if (st == en) { Operators.complete(actual); return; } else if (st + 1 == en) { actual.onSubscribe(Operators.scalarSubscription(actual, (int)st)); return; } if (actual instanceof ConditionalSubscriber) { actual.onSubscribe(new RangeSubscriptionConditional((ConditionalSubscriber<? super Integer>) actual, st, en)); return; } actual.onSubscribe(new RangeSubscription(actual, st, en)); }
@Test public void prematureCompleteSourceEmptyDouble() { DirectProcessor<Integer> d = DirectProcessor.create(); StepVerifier.create(Flux.zip(obj -> 0, d, s -> { CoreSubscriber<?> a = ((DirectProcessor.DirectInner) d.inners().findFirst().get()) .actual; Operators.complete(s); a.onComplete(); }, Mono.just(1))) .verifyComplete(); }
@Test public void conditionalFusionAvailable() { AssertSubscriber<Object> ts = AssertSubscriber.create(); Flux.wrap(u -> { if (!(u instanceof Fuseable.ConditionalSubscriber)) { Operators.error(u, new IllegalArgumentException("The subscriber is not conditional: " + u)); } else { Operators.complete(u); } }) .doOnNext(v -> { }) .filter(v -> true) .subscribe(ts); ts.assertNoError() .assertNoValues() .assertComplete(); }
@Test public void conditionalFusionAvailable() { AssertSubscriber<Object> ts = AssertSubscriber.create(); Flux.from(u -> { if (!(u instanceof Fuseable.ConditionalSubscriber)) { Operators.error(u, new IllegalArgumentException("The subscriber is not conditional: " + u)); } else { Operators.complete(u); } }) .doOnNext(v -> { }) .filter(v -> true) .subscribe(ts); ts.assertNoError() .assertNoValues() .assertComplete(); }
@Test public void conditionalFusionAvailableWithFuseable() { AssertSubscriber<Object> ts = AssertSubscriber.create(); Flux.wrap(u -> { if (!(u instanceof Fuseable.ConditionalSubscriber)) { Operators.error(u, new IllegalArgumentException("The subscriber is not conditional: " + u)); } else { Operators.complete(u); } }) .doOnNext(v -> { }) .filter(v -> true) .subscribe(ts); ts.assertNoError() .assertNoValues() .assertComplete(); }
@Test public void conditionalFusionAvailableWithFuseable() { AssertSubscriber<Object> ts = AssertSubscriber.create(); Flux.wrap(u -> { if (!(u instanceof Fuseable.ConditionalSubscriber)) { Operators.error(u, new IllegalArgumentException("The subscriber is not conditional: " + u)); } else { Operators.complete(u); } }) .doOnNext(v -> { }) .filter(v -> true) .subscribe(ts); ts.assertNoError() .assertNoValues() .assertComplete(); }