void reportError(Subscriber<?>[] subscribers, Throwable ex) { for (Subscriber<?> s : subscribers) { Operators.error(s, ex); } }
void reportError(Subscriber<?>[] subscribers, Throwable ex) { for (Subscriber<?> s : subscribers) { Operators.error(s, ex); } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { if (ONCE.compareAndSet(this, 0, 1)) { this.actual = actual; actual.onSubscribe(this); } else { Operators.error(actual, new IllegalStateException("This ParallelGroup can be subscribed to at most once.")); } }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Throwable error = Objects.requireNonNull(errorSupplier.get(), "the errorSupplier returned null"); Operators.error(actual, Operators.onOperatorError(error, actual.currentContext())); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Throwable error = Objects.requireNonNull(errorSupplier.get(), "errorSupplier produced a null Throwable"); Operators.error(actual, Operators.onOperatorError(error, actual.currentContext())); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Operators.error(actual, Operators.onOperatorError(error, actual.currentContext())); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Operators.error(actual, Operators.onOperatorError(error, actual.currentContext())); }
@SuppressWarnings("unchecked") public void subscribe(CoreSubscriber<? super T> actual) { Mono<? extends T> p; try { p = Objects.requireNonNull(supplier.get(), "The Mono returned by the supplier is null"); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } p.subscribe(actual); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Iterator<? extends T> it; try { it = iterable.iterator(); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } subscribe(actual, it, onClose); }
@Override public void onError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, Operators.cancelledSubscription())) { Operators.error(actual, t); return; } } cancel(); actual.onError(t); }
@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); }
@Override public void subscribe(CoreSubscriber<? super C> actual) { C collection; try { collection = Objects.requireNonNull(collectionSupplier.get(), "The collectionSupplier returned a null collection"); } catch (Throwable ex) { Operators.error(actual, Operators.onOperatorError(ex, actual.currentContext())); return; } source.subscribe(new MonoBufferAllSubscriber<>(actual, collection)); }
@Override @SuppressWarnings("unchecked") public void subscribe(CoreSubscriber<? super T> actual) { Publisher<? extends T> p; try { p = Objects.requireNonNull(supplier.get(), "The Publisher returned by the supplier is null"); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } from(p).subscribe(actual); }
void otherError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, Operators.cancelledSubscription())) { cancelMain(); Operators.error(actual, t); return; } } cancelMain(); otherValue = null; actual.onError(t); }
@Override public void onError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, Operators.cancelledSubscription())) { cancelOther(); Operators.error(actual, t); return; } } cancelOther(); otherValue = null; actual.onError(t); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { S state; try { state = stateSupplier.call(); } catch (Throwable e) { Operators.error(actual, Operators.onOperatorError(e, actual.currentContext())); return; } actual.onSubscribe(new GenerateSubscription<>(actual, state, generator, stateConsumer)); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Context c; try { c = doOnContext.apply(actual.currentContext()); } catch (Throwable t) { Operators.error(actual, Operators.onOperatorError(t, actual.currentContext())); return; } source.subscribe(new ContextStartSubscriber<>(actual, c)); }
@Override public void subscribe(CoreSubscriber<? super T> actual) { Context c; try { c = doOnContext.apply(actual.currentContext()); } catch (Throwable t) { Operators.error(actual, Operators.onOperatorError(t, actual.currentContext())); return; } source.subscribe(new FluxContextStart.ContextStartSubscriber<>(actual, c)); }
@Override public void onError(Throwable t) { if (MAIN.compareAndSet(this, null, Operators.cancelledSubscription())) { Operators.error(actual, t); return; } else if (main == Operators.cancelledSubscription()){ Operators.onErrorDropped(t, actual.currentContext()); return; } cancel(); actual.onError(t); }
@Override protected List<Scenario<String, String>> scenarios_operatorError() { return Arrays.asList( scenario(f -> f.skipUntilOther(Flux.error(exception()))), scenario(f -> f.skipUntilOther(Flux.from(s -> { Operators.error(s, exception()); //touch dropped items s.onNext(item(0)); s.onNext(item(0)); s.onComplete(); s.onComplete(); }))) ); }