@Override public void subscribe(Subscriber<? super Object> s) { SubscriptionHelper.complete(s); }
@Override public void subscribe(Subscriber<? super Object> s) { s.onSubscribe(SubscriptionHelper.empty()); }
void reportError(Subscriber<?>[] subscribers, Throwable ex) { for (Subscriber<?> s : subscribers) { SubscriptionHelper.error(s, ex); } }
void setOther(Subscription s) { if (!OTHER.compareAndSet(this, null, s)) { s.cancel(); if (other != SubscriptionHelper.cancelled()) { SubscriptionHelper.reportSubscriptionSet(); } } }
it = other.iterator(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; SubscriptionHelper.error(s, new NullPointerException("The other iterable produced a null iterator")); return; b = it.hasNext(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; SubscriptionHelper.complete(s); return;
@Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } }
@Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; try { parent.onSubscribe.accept(s); } catch (Throwable ex) { ExceptionHelper.throwIfFatal(ex); s.cancel(); actual.onSubscribe(SubscriptionHelper.empty()); onError(ex); return; } actual.onSubscribe(this); } }
@Override public void onNext(T t) { long idx = INDEX.incrementAndGet(this); if (!SubscriptionHelper.set(OTHER, this, SubscriptionHelper.empty())) { return; } Publisher<U> p; try { p = throttler.apply(t); } catch (Throwable e) { ExceptionHelper.throwIfFatal(e); onError(ExceptionHelper.unwrap(e)); return; } if (p == null) { onError(new NullPointerException("The throttler returned a null publisher")); return; } PublisherThrottleTimeoutOther<T, U> os = new PublisherThrottleTimeoutOther<>(this, t, idx); if (SubscriptionHelper.replace(OTHER, this, os)) { p.subscribe(os); } }
@Override public boolean isTerminated() { return done || s == SubscriptionHelper.cancelled(); } }
public final void produced(long n) { if (unbounded) { return; } if (wip == 0 && WIP.compareAndSet(this, 0, 1)) { long r = requested; if (r != Long.MAX_VALUE) { long u = r - n; if (u < 0L) { SubscriptionHelper.reportMoreProduced(); u = 0; } requested = u; } else { unbounded = true; } if (WIP.decrementAndGet(this) == 0) { return; } drainLoop(); return; } BackpressureHelper.getAndAddCap(MISSED_PRODUCED, this, n); drain(); }
public static boolean validate(long n) { if (n < 0) { reportBadRequest(n); return false; } return true; }
public static boolean validate(Subscription current, Subscription next) { Objects.requireNonNull(next, "Subscription cannot be null"); if (current != null) { next.cancel(); reportSubscriptionSet(); return false; } return true; }
/** * Common method to take an Iterator as a source of values. * * @param s * @param it */ static <T> void subscribe(Subscriber<? super T> s, Iterator<? extends T> it) { if (it == null) { SubscriptionHelper.error(s, new NullPointerException("The iterator is null")); return; } boolean b; try { b = it.hasNext(); } catch (Throwable e) { SubscriptionHelper.error(s, e); return; } if (!b) { SubscriptionHelper.complete(s); return; } if (s instanceof ConditionalSubscriber) { s.onSubscribe(new IterableSubscriptionConditional<>((ConditionalSubscriber<? super T>)s, it)); } else { s.onSubscribe(new IterableSubscription<>(s, it)); } }
@Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); } }
void setOther(Subscription s) { if (!OTHER.compareAndSet(this, null, s)) { s.cancel(); if (other != SubscriptionHelper.cancelled()) { SubscriptionHelper.reportSubscriptionSet(); } } }