void subscribe(Publisher<? extends T>[] sources, int n) { CombineLatestInnerSubscriber<T>[] a = subscribers; for (int i = 0; i < n; i++) { if (done || cancelled) { return; } sources[i].subscribe(a[i]); } }
@Override protected void subscribeActual(Subscriber<? super T> s) { publisher.subscribe(s); } }
void subscribe(Publisher<?>[] others, int n) { WithLatestInnerSubscriber[] subscribers = this.subscribers; AtomicReference<Subscription> upstream = this.upstream; for (int i = 0; i < n; i++) { if (upstream.get() == SubscriptionHelper.CANCELLED) { return; } others[i].subscribe(subscribers[i]); } }
@Override protected void subscribeActual(Subscriber<? super T> s) { source.subscribe(new TakeSubscriber<T>(s, limit)); } }
@Override public void subscribeActual(CompletableObserver observer) { CompletableMergeSubscriber parent = new CompletableMergeSubscriber(observer, maxConcurrency, delayErrors); source.subscribe(parent); }
@Override public void onComplete() { Publisher<? extends R> p = other; if (p == null) { downstream.onComplete(); } else { other = null; p.subscribe(this); } }
void subscribe(Publisher<? extends T>[] sources, int n) { ZipSubscriber<T, R>[] a = subscribers; for (int i = 0; i < n; i++) { if (cancelled || (!delayErrors && errors.get() != null)) { return; } sources[i].subscribe(a[i]); } }
@Override public void subscribe(Subscriber<? super T>[] subscribers) { if (!validate(subscribers)) { return; } int n = subscribers.length; for (int i = 0; i < n; i++) { sources[i].subscribe(subscribers[i]); } } }
@Override public void subscribeActual(final Subscriber<? super T> child) { MainSubscriber<T> parent = new MainSubscriber<T>(child, main); child.onSubscribe(parent); other.subscribe(parent.other); }
@Override protected void subscribeActual(Subscriber<? super R> s) { source.subscribe(new ConcatMapEagerDelayErrorSubscriber<T, R>( s, mapper, maxConcurrency, prefetch, errorMode)); } }
@Override public void run() { lazySet(Thread.currentThread()); Publisher<T> src = source; source = null; src.subscribe(this); }
@Override public void onComplete() { if (empty) { empty = false; other.subscribe(this); } else { downstream.onComplete(); } } }
@Override public void onSubscribe(Subscription s) { if (SubscriptionHelper.validate(this.upstream, s)) { this.upstream = s; downstream.onSubscribe(this); if (other.get() == null) { sampler.subscribe(new SamplerSubscriber<T>(this)); s.request(Long.MAX_VALUE); } } }
@Override protected void subscribeActual(Subscriber<? super T> child) { TakeUntilMainSubscriber<T> parent = new TakeUntilMainSubscriber<T>(child); child.onSubscribe(parent); other.subscribe(parent.other); source.subscribe(parent); }
void startFirstTimeout(Publisher<?> firstTimeoutIndicator) { if (firstTimeoutIndicator != null) { TimeoutConsumer consumer = new TimeoutConsumer(0L, this); if (task.replace(consumer)) { firstTimeoutIndicator.subscribe(consumer); } } }
@Override protected void subscribeActual(Subscriber<? super U> s) { if (FlowableScalarXMap.tryScalarXMapSubscribe(source, s, mapper)) { return; } source.subscribe(FlowableFlatMap.subscribe(s, mapper, delayErrors, maxConcurrency, bufferSize)); } }
@Override protected void subscribeActual(MaybeObserver<? super T> observer) { TimeoutMainMaybeObserver<T, U> parent = new TimeoutMainMaybeObserver<T, U>(observer, fallback); observer.onSubscribe(parent); other.subscribe(parent.other); source.subscribe(parent); }
@Override protected void subscribeActual(SingleObserver<? super T> observer) { TakeUntilMainObserver<T> parent = new TakeUntilMainObserver<T>(observer); observer.onSubscribe(parent); other.subscribe(parent.other); source.subscribe(parent); }
@Override public void onSuccess(S value) { Publisher<? extends T> f; try { f = ObjectHelper.requireNonNull(mapper.apply(value), "the mapper returned a null Publisher"); } catch (Throwable e) { Exceptions.throwIfFatal(e); downstream.onError(e); return; } f.subscribe(this); }
@Override protected void subscribeActual(Subscriber<? super R> s) { GroupJoinSubscription<TLeft, TRight, TLeftEnd, TRightEnd, R> parent = new GroupJoinSubscription<TLeft, TRight, TLeftEnd, TRightEnd, R>(s, leftEnd, rightEnd, resultSelector); s.onSubscribe(parent); LeftRightSubscriber left = new LeftRightSubscriber(parent, true); parent.disposables.add(left); LeftRightSubscriber right = new LeftRightSubscriber(parent, false); parent.disposables.add(right); source.subscribe(left); other.subscribe(right); }