@Override protected void subscribeActual(Observer<? super T> observer) { source.subscribe(observer); } }
@Override public void subscribeActual(CompletableObserver s) { CompletableMergeObserver parent = new CompletableMergeObserver(s, maxConcurrency, delayErrors); source.subscribe(parent); }
@Override public Iterator<T> iterator() { BlockingObservableIterator<T> it = new BlockingObservableIterator<T>(bufferSize); source.subscribe(it); return it; }
@Override public void subscribeActual(Observer<? super R> t) { final SerializedObserver<R> serial = new SerializedObserver<R>(t); final WithLatestFromObserver<T, U, R> wlf = new WithLatestFromObserver<T, U, R>(serial, combiner); serial.onSubscribe(wlf); other.subscribe(new WithLastFrom(wlf)); source.subscribe(wlf); }
@Override public void subscribeActual(Observer<? super T> t) { if (other == null) { source.subscribe(new TimeoutObserver<T, U, V>( new SerializedObserver<T>(t), firstTimeoutIndicator, itemTimeoutIndicator)); } else { source.subscribe(new TimeoutOtherObserver<T, U, V>( t, firstTimeoutIndicator, itemTimeoutIndicator, other)); } }
@Override public void timeout(long idx) { if (idx == index) { dispose(); other.subscribe(new FullArbiterObserver<T>(arbiter)); } }
@Override public void subscribeActual(Observer<? super U> t) { if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) { return; } source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize)); }
@Override public void subscribeActual(Observer<? super R> t) { final SerializedObserver<R> serial = new SerializedObserver<R>(t); final WithLatestFromObserver<T, U, R> wlf = new WithLatestFromObserver<T, U, R>(serial, combiner); serial.onSubscribe(wlf); other.subscribe(new WithLastFrom(wlf)); source.subscribe(wlf); }
@Override public void onSubscribe(Disposable s) { if (DisposableHelper.validate(this.s, s)) { this.s = s; actual.onSubscribe(this); if (other.get() == null) { sampler.subscribe(new SamplerObserver<T>(this)); } } }
@Override public void subscribeActual(Observer<? super T> child) { final SerializedObserver<T> serial = new SerializedObserver<T>(child); final ArrayCompositeDisposable frc = new ArrayCompositeDisposable(2); serial.onSubscribe(frc); final SkipUntilObserver<T> sus = new SkipUntilObserver<T>(serial, frc); other.subscribe(new SkipUntil(frc, sus, serial)); source.subscribe(sus); }
@Override protected void subscribeActual(Observer<? super U> t) { source.subscribe(new BufferBoundaryObserver<T, U, Open, Close>( new SerializedObserver<U>(t), bufferOpen, bufferClose, bufferSupplier )); }
@Override protected void subscribeActual(Observer<? super R> s) { GroupJoinDisposable<TLeft, TRight, TLeftEnd, TRightEnd, R> parent = new GroupJoinDisposable<TLeft, TRight, TLeftEnd, TRightEnd, R>(s, leftEnd, rightEnd, resultSelector); s.onSubscribe(parent); LeftRightObserver left = new LeftRightObserver(parent, true); parent.disposables.add(left); LeftRightObserver right = new LeftRightObserver(parent, false); parent.disposables.add(right); source.subscribe(left); other.subscribe(right); }
@Override protected void subscribeActual(Observer<? super T> observer) { Collection<? super K> collection; try { collection = ObjectHelper.requireNonNull(collectionSupplier.call(), "The collectionSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources."); } catch (Throwable ex) { Exceptions.throwIfFatal(ex); EmptyDisposable.error(ex, observer); return; } source.subscribe(new DistinctObserver<T, K>(observer, keySelector, collection)); }
@Override public void subscribeActual(final Observer<? super T> child) { final SequentialDisposable serial = new SequentialDisposable(); child.onSubscribe(serial); Observer<U> otherObserver = new DelayObserver(serial, child); other.subscribe(otherObserver); }
@Override public void subscribeActual(SingleObserver<? super U> t) { U coll; try { coll = ObjectHelper.requireNonNull(collectionSupplier.call(), "The collectionSupplier returned a null collection. Null values are generally not allowed in 2.x operators and sources."); } catch (Throwable e) { Exceptions.throwIfFatal(e); EmptyDisposable.error(e, t); return; } source.subscribe(new ToListObserver<T, U>(t, coll)); }