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 subscribeNext() { otherSource.subscribe(other); } }
@Override protected void subscribeActual(Subscriber<? super T> s) { onSubscribe.subscribe(s); }
@Override protected void subscribeActual(Subscriber<? super T> s) { onSubscribe.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 protected void subscribeActual(Subscriber<? super U> s) { source.subscribe(new MapSubscriber<T, U>(s, mapper)); } }
@Override public void onComplete() { if (empty) { empty = false; other.subscribe(this); } else { downstream.onComplete(); } } }
@Override protected void subscribeActual(final SingleObserver<? super T> observer) { publisher.subscribe(new ToSingleObserver<T>(observer)); }
@Override protected void subscribeActual(final CompletableObserver downstream) { flowable.subscribe(new FromPublisherSubscriber<T>(downstream)); }
@Override public void subscribeActual(CompletableObserver observer) { sources.subscribe(new CompletableConcatSubscriber(observer, prefetch)); }