void reportError(Subscriber<?>[] subscribers, Throwable ex) { for (Subscriber<?> s : subscribers) { SubscriptionHelper.error(s, ex); } }
void reportError(Subscriber<?>[] subscribers, Throwable ex) { for (Subscriber<?> s : subscribers) { SubscriptionHelper.error(s, ex); } }
void reportError(Subscriber<?>[] subscribers, Throwable ex) { for (Subscriber<?> s : subscribers) { SubscriptionHelper.error(s, ex); } }
@Override public void subscribe(Subscriber<? super T> s) { if (ONCE.compareAndSet(this, 0, 1)) { this.actual = s; s.onSubscribe(this); } else { SubscriptionHelper.error(s, new IllegalStateException("This ParallelGroup can be subscribed to at most once.")); } }
@Override public void subscribe(Subscriber<? super T> s) { S state; try { state = stateSupplier.call(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } s.onSubscribe(new GenerateSubscription<>(s, state, generator, stateConsumer)); }
@Override public void subscribe(Subscriber<? super T> s) { Iterator<? extends T> it; try { it = iterable.iterator(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } subscribe(s, it); }
@Override public void subscribe(Subscriber<? super T> s) { Iterator<? extends T> it; try { it = stream.iterator(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } PublisherIterable.subscribe(s, it); }
@Override public void subscribe(Subscriber<? super T> s) { if (once == 0 && ONCE.compareAndSet(this, 0, 1)) { s.onSubscribe(this); actual = s; if (cancelled) { actual = null; } else { drain(); } } else { SubscriptionHelper.error(s, new IllegalStateException("This processor allows only a single Subscriber")); } }
@Override public void subscribe(Subscriber<? super R> s) { R container; try { container = supplier.get(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } if (container == null) { SubscriptionHelper.error(s, new NullPointerException("The supplier returned a null container")); return; } source.subscribe(new PublisherCollectSubscriber<>(s, action, container)); }
@Override public void subscribe(Subscriber<? super R> s) { R initialValue; try { initialValue = initialSupplier.get(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } if (initialValue == null) { SubscriptionHelper.error(s, new NullPointerException("The initial value supplied is null")); return; } source.subscribe(new PublisherReduceSubscriber<>(s, accumulator, initialValue)); }
@Override public void subscribe(Subscriber<? super T> s) { C collection; try { collection = collectionSupplier.get(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } if (collection == null) { SubscriptionHelper.error(s, new NullPointerException("The collectionSupplier returned a null collection")); return; } source.subscribe(new PublisherDistinctFuseableSubscriber<>(s, collection, keyExtractor)); }
@Override public void subscribe(Subscriber<? super T> s) { Throwable e; try { e = supplier.get(); } catch (Throwable ex) { e = ex; } if (e == null) { e = new NullPointerException("The Throwable returned by the supplier is null"); } if (whenRequested) { s.onSubscribe(new PublisherErrorSubscription(s, e)); } else { SubscriptionHelper.error(s, e); } }
@Override public void subscribe(Subscriber<? super GroupedPublisher<K, V>> s) { Queue<GroupedPublisher<K, V>> q; try { q = mainQueueSupplier.get(); } catch (Throwable ex) { ExceptionHelper.throwIfFatal(ex); SubscriptionHelper.error(s, ex); return; } if (q == null) { SubscriptionHelper.error(s, new NullPointerException("The mainQueueSupplier returned a null queue")); return; } source.subscribe(new PublisherGroupByMain<>(s, q, groupQueueSupplier, prefetch, keySelector, valueSelector)); }
@Override public void onError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, SubscriptionHelper.cancelled())) { SubscriptionHelper.error(actual, t); return; } } cancel(); actual.onError(t); }
@Override public void onError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, SubscriptionHelper.cancelled())) { SubscriptionHelper.error(actual, t); return; } } cancel(); actual.onError(t); }
void otherError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, SubscriptionHelper.cancelled())) { cancelMain(); SubscriptionHelper.error(actual, t); return; } } cancelMain(); otherValue = null; actual.onError(t); }
@Override public void onError(Throwable t) { if (main == null) { if (MAIN.compareAndSet(this, null, SubscriptionHelper.cancelled())) { cancelOther(); SubscriptionHelper.error(actual, t); return; } } cancelOther(); otherValue = null; actual.onError(t); }
@Override public void subscribe(Subscriber<? super R> s) { A container; BiConsumer<A, T> accumulator; Function<A, R> finisher; try { container = collector.supplier().get(); accumulator = collector.accumulator(); finisher = collector.finisher(); } catch (Throwable ex) { ExceptionHelper.throwIfFatal(ex); SubscriptionHelper.error(s, ex); return; } source.subscribe(new PublisherStreamCollectorSubscriber<>(s, container, accumulator, finisher)); }
@Test public void conditionalFusionAvailableWithFuseable() { TestSubscriber<Object> ts = new TestSubscriber<>(); Px.wrapFuseable(u -> { if (!(u instanceof Fuseable.ConditionalSubscriber)) { SubscriptionHelper.error(u, new IllegalArgumentException("The subscriber is not conditional: " + u)); } else { SubscriptionHelper.complete(u); } }).doOnNext(v -> { }).filter(v -> true).subscribe(ts); ts.assertNoError() .assertNoValues() .assertComplete(); }
@Test public void conditionalFusionAvailable() { TestSubscriber<Object> ts = new TestSubscriber<>(); Px.wrap(u -> { if (!(u instanceof Fuseable.ConditionalSubscriber)) { SubscriptionHelper.error(u, new IllegalArgumentException("The subscriber is not " + "conditional: " + u)); } else { SubscriptionHelper.complete(u); } }).doOnNext(v -> { }).filter(v -> true).subscribe(ts); ts.assertNoError() .assertNoValues() .assertComplete(); }