Uses of Interface
io.reactivex.rxjava3.core.ObservableSource

Packages that use ObservableSource

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.internal.fuseable	Base interfaces and types for supporting operator-fusion.
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.mixed
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.observables	Classes supporting the Observable base reactive class: ConnectableObservable and GroupedObservable.
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.

Uses of ObservableSource in io.reactivex.rxjava3.core

Classes in io.reactivex.rxjava3.core that implement ObservableSource

Modifier and Type	Class	Description
class	Observable<T>	The Observable class is the non-backpressured, optionally multi-valued base reactive class that offers factory methods, intermediate operators and the ability to consume synchronous and/or asynchronous reactive dataflows.

Methods in io.reactivex.rxjava3.core that return ObservableSource

Modifier and Type	Method	Description
@NonNull ObservableSource<Downstream>	ObservableTransformer.apply(@NonNull Observable<@NonNull Upstream> upstream)	Applies a function to the upstream Observable and returns an ObservableSource with optionally different element type.

Methods in io.reactivex.rxjava3.core with parameters of type ObservableSource

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Observable<T>	Observable.ambArray(@NonNull ObservableSource<? extends @NonNull T>... sources)	Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends a termination notification.
@NonNull Observable<T>	Observable.ambWith(@NonNull ObservableSource<? extends @NonNull T> other)	Mirrors the current Observable or the other ObservableSource provided of which the first either emits an item or sends a termination notification.
<@NonNull T> @NonNull Observable<T>	Completable.andThen(@NonNull ObservableSource<@NonNull T> next)	Returns an Observable which will subscribe to this Completable and once that is completed then will subscribe to the next ObservableSource.
<@NonNull TOpening,@NonNull TClosing> @NonNull Observable<@NonNull java.util.List<T>>	Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening,? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator)	Returns an Observable that emits buffers of items it collects from the current Observable.
<@NonNull TOpening,@NonNull TClosing,@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U>	Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening,? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns an Observable that emits buffers of items it collects from the current Observable.
<@NonNull B> @NonNull Observable<@NonNull java.util.List<T>>	Observable.buffer(@NonNull ObservableSource<@NonNull B> boundaryIndicator)	Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.
<@NonNull B> @NonNull Observable<@NonNull java.util.List<T>>	Observable.buffer(@NonNull ObservableSource<@NonNull B> boundaryIndicator, int initialCapacity)	Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.
<@NonNull B,@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U>	Observable.buffer(@NonNull ObservableSource<@NonNull B> boundaryIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull T9,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? super @NonNull T9,? extends @NonNull R> combiner)	Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? extends @NonNull R> combiner)	Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? extends @NonNull R> combiner)	Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? extends @NonNull R> combiner)	Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? extends @NonNull R> combiner)	Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> combiner)	Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> combiner)	Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> combiner)	Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from either of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatestArray(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner)	Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatestArray(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner, int bufferSize)	Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatestArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner)	Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatestArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>[] sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner, int bufferSize)	Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the ObservableSource, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize)	Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the outer ObservableSource, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3)	Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4)	Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends @NonNull T> source1, ObservableSource<? extends @NonNull T> source2)	Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Single.concat(@NonNull ObservableSource<? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an ObservableSource sequence.
static <@NonNull T> @NonNull Observable<T>	Observable.concatArray(@NonNull ObservableSource<? extends @NonNull T>... sources)	Concatenates a variable number of ObservableSource sources.
static <@NonNull T> @NonNull Observable<T>	Observable.concatArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>... sources)	Concatenates a variable number of ObservableSource sources and delays errors from any of them till all terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatArrayEager(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources)	Concatenates an array of ObservableSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Observable<T>	Observable.concatArrayEager(@NonNull ObservableSource<? extends @NonNull T>... sources)	Concatenates an array of ObservableSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Observable<T>	Observable.concatArrayEagerDelayError(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources)	Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatArrayEagerDelayError(@NonNull ObservableSource<? extends @NonNull T>... sources)	Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize, boolean tillTheEnd)	Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.
@NonNull Observable<T>	Observable.concatWith(@NonNull ObservableSource<? extends @NonNull T> other)	Returns an Observable that first emits the items emitted from the current Observable, then items from the other ObservableSource without interleaving them.
<@NonNull U,@NonNull V> @NonNull Observable<T>	Observable.delay(@NonNull ObservableSource<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemDelayIndicator)	Returns an Observable that delays the subscription to and emissions from the current Observable via ObservableSources for the subscription itself and on a per-item basis.
<@NonNull U> @NonNull Observable<T>	Observable.delaySubscription(@NonNull ObservableSource<@NonNull U> subscriptionIndicator)	Returns an Observable that delays the subscription to the current Observable until the other ObservableSource emits an element or completes normally.
<@NonNull U> @NonNull Single<T>	Single.delaySubscription(@NonNull ObservableSource<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
static <@NonNull T> @NonNull Completable	Completable.fromObservable(@NonNull ObservableSource<@NonNull T> observable)	Returns a Completable instance that subscribes to the given ObservableSource, ignores all values and emits only the terminal event.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromObservable(@NonNull ObservableSource<@NonNull T> source, @NonNull BackpressureStrategy strategy)	Converts the given ObservableSource into a Flowable by applying the specified backpressure strategy.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromObservable(@NonNull ObservableSource<@NonNull T> source)	Wraps an ObservableSource into a Maybe and emits the very first item or completes if the source is empty.
static <@NonNull T> @NonNull Single<T>	Single.fromObservable(@NonNull ObservableSource<? extends @NonNull T> observable)	Wraps a specific ObservableSource into a Single and signals its single element or error.
<@NonNull TRight,@NonNull TLeftEnd,@NonNull TRightEnd,@NonNull R> @NonNull Observable<R>	Observable.groupJoin(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super Observable<@NonNull TRight>,? extends @NonNull R> resultSelector)	Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
<@NonNull TRight,@NonNull TLeftEnd,@NonNull TRightEnd,@NonNull R> @NonNull Observable<R>	Observable.join(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super @NonNull TRight,? extends @NonNull R> resultSelector)	Correlates the items emitted by two ObservableSources based on overlapping durations.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2)	Flattens two ObservableSources into a single Observable, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3)	Flattens three ObservableSources into a single Observable, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4)	Flattens four ObservableSources into a single Observable, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeArray(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources)	Flattens an array of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeArray(@NonNull ObservableSource<? extends @NonNull T>... sources)	Flattens an array of ObservableSources into one Observable, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeArrayDelayError(int maxConcurrency, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources)	Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeArrayDelayError(@NonNull ObservableSource<? extends @NonNull T>... sources)	Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2)	Flattens two ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3)	Flattens three ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull ObservableSource<? extends @NonNull T> source3, @NonNull ObservableSource<? extends @NonNull T> source4)	Flattens four ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.
@NonNull Observable<T>	Observable.mergeWith(@NonNull ObservableSource<? extends @NonNull T> other)	Flattens the current Observable and another ObservableSource into a single Observable sequence, without any transformation.
@NonNull Observable<T>	Observable.onErrorResumeWith(@NonNull ObservableSource<? extends @NonNull T> fallback)	Resumes the flow with the given ObservableSource when the current Observable fails instead of signaling the error via onError.
<@NonNull U> @NonNull Observable<T>	Observable.sample(@NonNull ObservableSource<@NonNull U> sampler)	Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource.
<@NonNull U> @NonNull Observable<T>	Observable.sample(@NonNull ObservableSource<@NonNull U> sampler, boolean emitLast)	Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, int bufferSize)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Observable.sequenceEqual(@NonNull ObservableSource<? extends @NonNull T> source1, @NonNull ObservableSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T,? super @NonNull T> isEqual, int bufferSize)	Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.
<@NonNull U> @NonNull Observable<T>	Observable.skipUntil(@NonNull ObservableSource<@NonNull U> other)	Returns an Observable that skips items emitted by the current Observable until a second ObservableSource emits an item.
<@NonNull T> @NonNull Observable<T>	Completable.startWith(@NonNull ObservableSource<@NonNull T> other)	Returns an Observable which first delivers the events of the other ObservableSource then runs the current Completable.
@NonNull Observable<T>	Maybe.startWith(@NonNull ObservableSource<@NonNull T> other)	Returns an Observable which first delivers the events of the other ObservableSource then runs the current Maybe.
@NonNull Observable<T>	Observable.startWith(@NonNull ObservableSource<? extends @NonNull T> other)	Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the current Observable.
@NonNull Observable<T>	Single.startWith(@NonNull ObservableSource<@NonNull T> other)	Returns an Observable which first delivers the events of the other ObservableSource then runs the current Single.
@NonNull Observable<T>	Observable.switchIfEmpty(@NonNull ObservableSource<? extends @NonNull T> other)	Returns an Observable that emits the items emitted by the current Observable or the items of an alternate ObservableSource if the current Observable is empty.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
<@NonNull U> @NonNull Observable<T>	Observable.takeUntil(@NonNull ObservableSource<@NonNull U> other)	Returns an Observable that emits the items emitted by the current Observable until a second ObservableSource emits an item or completes.
@NonNull Observable<T>	Observable.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item.
@NonNull Observable<T>	Observable.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item using a specified Scheduler.
<@NonNull U,@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator)	Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
<@NonNull U,@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
<@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
private @NonNull Observable<T>	Observable.timeout0(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @Nullable ObservableSource<? extends @NonNull T> fallback, @NonNull Scheduler scheduler)
private <U,V> @NonNull Observable<T>	Observable.timeout0(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<V>> itemTimeoutIndicator, @Nullable ObservableSource<? extends @NonNull T> fallback)
static <@NonNull T> @NonNull Observable<T>	Observable.unsafeCreate(@NonNull ObservableSource<@NonNull T> onSubscribe)	Create an Observable by wrapping an ObservableSource which has to be implemented according to the Observable specification derived from the Reactive Streams specification by handling disposal correctly; no safeguards are provided by the Observable itself.
<@NonNull B> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull B> boundaryIndicator)	Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
<@NonNull B> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull B> boundaryIndicator, int bufferSize)	Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.
<@NonNull U,@NonNull V> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,? extends ObservableSource<@NonNull V>> closingIndicator)	Returns an Observable that emits windows of items it collects from the current Observable.
<@NonNull U,@NonNull V> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,? extends ObservableSource<@NonNull V>> closingIndicator, int bufferSize)	Returns an Observable that emits windows of items it collects from the current Observable.
<@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull ObservableSource<?>[] others, @NonNull Function<? super java.lang.Object[],@NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner)	Merges the specified ObservableSource into the current Observable sequence by using the resultSelector function only when the current Observable emits an item.
<@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull ObservableSource<@NonNull T4> source4, @NonNull Function5<? super @NonNull T,? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,@NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull ObservableSource<@NonNull T3> source3, @NonNull Function4<? super @NonNull T,? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,@NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
<@NonNull T1,@NonNull T2,@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull ObservableSource<@NonNull T1> source1, @NonNull ObservableSource<@NonNull T2> source2, @NonNull Function3<? super @NonNull T,? super @NonNull T1,? super @NonNull T2,@NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
static <@NonNull T> @NonNull Observable<T>	Observable.wrap(@NonNull ObservableSource<@NonNull T> source)	Wraps an ObservableSource into an Observable if not already an Observable.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull T9,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull ObservableSource<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? super @NonNull T9,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull ObservableSource<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? super @NonNull T8,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull ObservableSource<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? super @NonNull T7,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull ObservableSource<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? super @NonNull T6,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull ObservableSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? super @NonNull T5,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull ObservableSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull ObservableSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper, boolean delayError)	Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull ObservableSource<? extends @NonNull T1> source1, @NonNull ObservableSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.zipArray(@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper, boolean delayError, int bufferSize, @NonNull ObservableSource<? extends @NonNull T>... sources)	Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other ObservableSources.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.zipWith(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper)	Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.zipWith(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper, boolean delayError)	Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.zipWith(@NonNull ObservableSource<? extends @NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

Method parameters in io.reactivex.rxjava3.core with type arguments of type ObservableSource

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Observable<T>	Observable.amb(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends a termination notification.
<@NonNull TOpening,@NonNull TClosing> @NonNull Observable<@NonNull java.util.List<T>>	Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening,? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator)	Returns an Observable that emits buffers of items it collects from the current Observable.
<@NonNull TOpening,@NonNull TClosing,@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U>	Observable.buffer(@NonNull ObservableSource<? extends @NonNull TOpening> openingIndicator, @NonNull Function<? super @NonNull TOpening,? extends ObservableSource<? extends @NonNull TClosing>> closingIndicator, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns an Observable that emits buffers of items it collects from the current Observable.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner)	Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatest(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner, int bufferSize)	Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatestDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner)	Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.combineLatestDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> combiner, int bufferSize)	Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the ObservableSource, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize)	Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the outer ObservableSource, one after the other, without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concat(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence of elements without interleaving them.
static <@NonNull T> @NonNull Observable<T>	Observable.concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize, boolean tillTheEnd)	Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of ObservableSources into a single Observable sequence by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till the all inner ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEager(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEager(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates a sequence of ObservableSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEager(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Concatenates a sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEagerDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEagerDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Concatenates a sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner sequences terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.concatEagerDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Concatenates a sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.
<@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize, @NonNull Scheduler scheduler)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapEager(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapEager(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency, int bufferSize)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapEagerDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int maxConcurrency, int bufferSize)	Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.
<@NonNull U> @NonNull Observable<T>	Observable.debounce(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull U>> debounceIndicator)	Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated inner ObservableSource for that original item.
static <@NonNull T> @NonNull Observable<T>	Observable.defer(@NonNull Supplier<? extends @NonNull ObservableSource<? extends @NonNull T>> supplier)	Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes.
<@NonNull U,@NonNull V> @NonNull Observable<T>	Observable.delay(@NonNull ObservableSource<@NonNull U> subscriptionIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemDelayIndicator)	Returns an Observable that delays the subscription to and emissions from the current Observable via ObservableSources for the subscription itself and on a per-item basis.
<@NonNull U> @NonNull Observable<T>	Observable.delay(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull U>> itemDelayIndicator)	Returns an Observable that delays the emissions of the current Observable via a per-item derived ObservableSource's item emission or termination, on a per source item basis.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int maxConcurrency)	Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super java.lang.Throwable,? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier)	Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<? super java.lang.Throwable,? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier)	Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<java.lang.Throwable,? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency)	Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> onNextMapper, @NonNull Function<java.lang.Throwable,? extends ObservableSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends ObservableSource<? extends @NonNull R>> onCompleteSupplier, int maxConcurrency)	Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, boolean delayErrors)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, boolean delayErrors, int maxConcurrency, int bufferSize)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull U,@NonNull R> @NonNull Observable<R>	Observable.flatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner, int maxConcurrency)	Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Maybe.flatMapObservable(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that is based on applying a specified function to the item emitted by the current Maybe, where that function returns an ObservableSource.
<@NonNull R> @NonNull Observable<R>	Single.flatMapObservable(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that is based on applying a specified function to the item emitted by the current Single, where that function returns an ObservableSource.
<@NonNull TRight,@NonNull TLeftEnd,@NonNull TRightEnd,@NonNull R> @NonNull Observable<R>	Observable.groupJoin(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super Observable<@NonNull TRight>,? extends @NonNull R> resultSelector)	Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
<@NonNull TRight,@NonNull TLeftEnd,@NonNull TRightEnd,@NonNull R> @NonNull Observable<R>	Observable.join(@NonNull ObservableSource<? extends @NonNull TRight> other, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull TLeftEnd>> leftEnd, @NonNull Function<? super @NonNull TRight,? extends ObservableSource<@NonNull TRightEnd>> rightEnd, @NonNull BiFunction<? super @NonNull T,? super @NonNull TRight,? extends @NonNull R> resultSelector)	Correlates the items emitted by two ObservableSources based on overlapping durations.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Flattens an Iterable of ObservableSources into one Observable, without any transformation.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.merge(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources)	Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.mergeDelayError(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, int maxConcurrency, int bufferSize)	Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
@NonNull Observable<T>	Observable.onErrorResumeNext(@NonNull Function<? super java.lang.Throwable,? extends ObservableSource<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a function instead of signaling the error via onError.
<@NonNull R> @NonNull Observable<R>	Observable.publish(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector)	Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable sequence.
@NonNull Observable<T>	Observable.repeatWhen(@NonNull Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>> handler)	Returns an Observable that emits the same values as the current Observable with the exception of an onComplete.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector)	Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableObservable that shares a single subscription to the current Observable.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull java.util.concurrent.TimeUnit unit)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, long time, @NonNull java.util.concurrent.TimeUnit unit)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
<@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, long time, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
@NonNull Observable<T>	Observable.retryWhen(@NonNull Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>> handler)	Returns an Observable that emits the same values as the current Observable with the exception of an onError.
<@NonNull R> @NonNull Observable<R>	Observable.switchMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.switchMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.
<@NonNull R> @NonNull Observable<R>	Observable.switchMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
<@NonNull R> @NonNull Observable<R>	Observable.switchMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize)	Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNext(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
static <@NonNull T> @NonNull Observable<T>	Observable.switchOnNextDelayError(@NonNull ObservableSource<? extends ObservableSource<? extends @NonNull T>> sources, int bufferSize)	Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
<@NonNull U,@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator)	Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
<@NonNull U,@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull ObservableSource<@NonNull U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.
<@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator)	Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
<@NonNull V> @NonNull Observable<T>	Observable.timeout(@NonNull Function<? super @NonNull T,? extends ObservableSource<@NonNull V>> itemTimeoutIndicator, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.
private <U,V> @NonNull Observable<T>	Observable.timeout0(@NonNull ObservableSource<U> firstTimeoutIndicator, @NonNull Function<? super @NonNull T,? extends ObservableSource<V>> itemTimeoutIndicator, @Nullable ObservableSource<? extends @NonNull T> fallback)
static <@NonNull T,@NonNull D> @NonNull Observable<T>	Observable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow.
static <@NonNull T,@NonNull D> @NonNull Observable<T>	Observable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided disposer function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.
<@NonNull U,@NonNull V> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,? extends ObservableSource<@NonNull V>> closingIndicator)	Returns an Observable that emits windows of items it collects from the current Observable.
<@NonNull U,@NonNull V> @NonNull Observable<Observable<T>>	Observable.window(@NonNull ObservableSource<@NonNull U> openingIndicator, @NonNull Function<? super @NonNull U,? extends ObservableSource<@NonNull V>> closingIndicator, int bufferSize)	Returns an Observable that emits windows of items it collects from the current Observable.
<@NonNull R> @NonNull Observable<R>	Observable.withLatestFrom(@NonNull java.lang.Iterable<? extends ObservableSource<?>> others, @NonNull Function<? super java.lang.Object[],@NonNull R> combiner)	Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper)	Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.
static <@NonNull T,@NonNull R> @NonNull Observable<R>	Observable.zip(@NonNull java.lang.Iterable<? extends ObservableSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper, boolean delayError, int bufferSize)	Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.

Uses of ObservableSource in io.reactivex.rxjava3.internal.fuseable

Methods in io.reactivex.rxjava3.internal.fuseable that return ObservableSource

Modifier and Type	Method	Description
@NonNull ObservableSource<T>	HasUpstreamObservableSource.source()	Returns the upstream source of this Observable.

Uses of ObservableSource in io.reactivex.rxjava3.internal.jdk8

Classes in io.reactivex.rxjava3.internal.jdk8 that implement ObservableSource

Modifier and Type	Class	Description
class	MaybeFlattenStreamAsObservable<T,R>	Map the success value into a Java Stream and emits its values.
class	ObservableCollectWithCollector<T,A,R>	Collect items into a container defined by a Stream Collector callback set.
class	ObservableFlatMapStream<T,R>	Maps the upstream values onto Streams and emits their items in order to the downstream.
class	ObservableFromCompletionStage<T>	Wrap a CompletionStage and signal its outcome.
class	ObservableFromStream<T>	Wraps a Stream and emits its values as an Observable sequence.
class	ObservableMapOptional<T,R>	Map the upstream values into an Optional and emit its value if any.
class	SingleFlattenStreamAsObservable<T,R>	Map the success value into a Java Stream and emits its values.

Uses of ObservableSource in io.reactivex.rxjava3.internal.operators.completable

Classes in io.reactivex.rxjava3.internal.operators.completable that implement ObservableSource

Modifier and Type	Class	Description
class	CompletableToObservable<T>	Wraps a Completable and exposes it as an Observable.

Fields in io.reactivex.rxjava3.internal.operators.completable declared as ObservableSource

Modifier and Type	Field	Description
(package private) ObservableSource<T>	CompletableFromObservable.observable

Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type ObservableSource

Constructor	Description
CompletableFromObservable(ObservableSource<T> observable)

Uses of ObservableSource in io.reactivex.rxjava3.internal.operators.flowable

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as ObservableSource

Modifier and Type	Field	Description
private ObservableSource<T>	FlowableFromObservable.upstream

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type ObservableSource

Constructor	Description
FlowableFromObservable(ObservableSource<T> upstream)

Uses of ObservableSource in io.reactivex.rxjava3.internal.operators.maybe

Classes in io.reactivex.rxjava3.internal.operators.maybe that implement ObservableSource

Modifier and Type	Class	Description
class	MaybeFlatMapIterableObservable<T,R>	Maps a success value into an Iterable and streams it back as a Flowable.
class	MaybeToObservable<T>	Wraps a MaybeSource and exposes it as an Observable, relaying signals in a backpressure-aware manner and composes cancellation through.

Uses of ObservableSource in io.reactivex.rxjava3.internal.operators.mixed

Classes in io.reactivex.rxjava3.internal.operators.mixed that implement ObservableSource

Modifier and Type	Class	Description
class	CompletableAndThenObservable<R>	After Completable completes, it relays the signals of the ObservableSource to the downstream observer.
class	MaybeFlatMapObservable<T,R>	Maps the success value of a Maybe onto an ObservableSource and relays its signals to the downstream observer.
class	ObservableConcatMapMaybe<T,R>	Maps each upstream item into a MaybeSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
class	ObservableConcatMapSingle<T,R>	Maps each upstream item into a SingleSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
class	ObservableSwitchMapMaybe<T,R>	Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value if available, optionally delaying errors from the main source or the inner sources.
class	ObservableSwitchMapSingle<T,R>	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value if available, optionally delaying errors from the main source or the inner sources.
class	SingleFlatMapObservable<T,R>	Maps the success value of a Single onto an ObservableSource and relays its signals to the downstream observer.

Fields in io.reactivex.rxjava3.internal.operators.mixed declared as ObservableSource

Modifier and Type	Field	Description
(package private) ObservableSource<? extends R>	CompletableAndThenObservable.AndThenObservableObserver.other
(package private) ObservableSource<? extends R>	CompletableAndThenObservable.other
(package private) ObservableSource<T>	ObservableConcatMapSingle.source

Fields in io.reactivex.rxjava3.internal.operators.mixed with type parameters of type ObservableSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends ObservableSource<? extends R>>	MaybeFlatMapObservable.FlatMapObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	MaybeFlatMapObservable.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	SingleFlatMapObservable.FlatMapObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	SingleFlatMapObservable.mapper

Constructors in io.reactivex.rxjava3.internal.operators.mixed with parameters of type ObservableSource

Constructor	Description
AndThenObservableObserver(Observer<? super R> downstream, ObservableSource<? extends R> other)
CompletableAndThenObservable(CompletableSource source, ObservableSource<? extends R> other)
ObservableConcatMapSingle(ObservableSource<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)

Constructor parameters in io.reactivex.rxjava3.internal.operators.mixed with type arguments of type ObservableSource

Constructor	Description
FlatMapObserver(Observer<? super R> downstream, Function<? super T,? extends ObservableSource<? extends R>> mapper)
FlatMapObserver(Observer<? super R> downstream, Function<? super T,? extends ObservableSource<? extends R>> mapper)
MaybeFlatMapObservable(MaybeSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper)
SingleFlatMapObservable(SingleSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper)

Uses of ObservableSource in io.reactivex.rxjava3.internal.operators.observable

Classes in io.reactivex.rxjava3.internal.operators.observable that implement ObservableSource

Modifier and Type	Class	Description
(package private) class	AbstractObservableWithUpstream<T,U>	Base class for operators with a source consumable.
class	ObservableAll<T>
class	ObservableAmb<T>
class	ObservableAny<T>
class	ObservableAutoConnect<T>	Wraps a ConnectableObservable and calls its connect() method once the specified number of Observers have subscribed.
class	ObservableBuffer<T,U extends java.util.Collection<? super T>>
class	ObservableBufferBoundary<T,U extends java.util.Collection<? super T>,Open,Close>
class	ObservableBufferExactBoundary<T,U extends java.util.Collection<? super T>,B>
class	ObservableBufferTimed<T,U extends java.util.Collection<? super T>>
class	ObservableCache<T>	An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.
class	ObservableCollect<T,U>
class	ObservableCombineLatest<T,R>
class	ObservableConcatMap<T,U>
class	ObservableConcatMapEager<T,R>
class	ObservableConcatMapScheduler<T,U>
class	ObservableConcatWithCompletable<T>	Subscribe to a main Observable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.
class	ObservableConcatWithMaybe<T>	Subscribe to a main Observable first, then when it completes normally, subscribe to a Maybe, signal its success value followed by a completion or signal its error or completion signal as is.
class	ObservableConcatWithSingle<T>	Subscribe to a main Observable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.
class	ObservableCount<T>
class	ObservableCreate<T>
class	ObservableDebounce<T,U>
class	ObservableDebounceTimed<T>
class	ObservableDefer<T>
class	ObservableDelay<T>
class	ObservableDelaySubscriptionOther<T,U>	Delays the subscription to the main source until the other observable fires an event or completes.
class	ObservableDematerialize<T,R>
class	ObservableDetach<T>	Breaks the links between the upstream and the downstream (the Disposable and the Observer references) when the sequence terminates or gets disposed.
class	ObservableDistinct<T,K>
class	ObservableDistinctUntilChanged<T,K>
class	ObservableDoAfterNext<T>	Calls a consumer after pushing the current item to the downstream.
class	ObservableDoFinally<T>	Execute an action after an onError, onComplete or a dispose event.
class	ObservableDoOnEach<T>
class	ObservableDoOnLifecycle<T>
class	ObservableElementAt<T>
class	ObservableEmpty
class	ObservableError<T>
class	ObservableFilter<T>
class	ObservableFlatMap<T,U>
class	ObservableFlatMapCompletable<T>	Maps a sequence of values into CompletableSources and awaits their termination.
class	ObservableFlatMapMaybe<T,R>	Maps upstream values into MaybeSources and merges their signals into one sequence.
class	ObservableFlatMapSingle<T,R>	Maps upstream values into SingleSources and merges their signals into one sequence.
class	ObservableFlattenIterable<T,R>	Maps a sequence into an Iterable and emits its values.
class	ObservableFromAction<T>	Executes an Action and signals its exception or completes normally.
class	ObservableFromArray<T>
class	ObservableFromCallable<T>	Calls a Callable and emits its resulting single value or signals its exception.
class	ObservableFromCompletable<T>	Wrap a Completable into an Observable.
class	ObservableFromFuture<T>
class	ObservableFromIterable<T>
class	ObservableFromPublisher<T>
class	ObservableFromRunnable<T>	Executes an Runnable and signals its exception or completes normally.
class	ObservableFromSupplier<T>	Calls a Supplier and emits its resulting single value or signals its exception.
class	ObservableFromUnsafeSource<T>
class	ObservableGenerate<T,S>
class	ObservableGroupBy<T,K,V>
(package private) static class	ObservableGroupBy.GroupedUnicast<K,T>
(package private) static class	ObservableGroupBy.State<T,K>
class	ObservableGroupJoin<TLeft,TRight,TLeftEnd,TRightEnd,R>
class	ObservableHide<T>	Hides the identity of the wrapped ObservableSource and its Disposable.
class	ObservableIgnoreElements<T>
class	ObservableInterval
class	ObservableIntervalRange
class	ObservableJoin<TLeft,TRight,TLeftEnd,TRightEnd,R>
class	ObservableJust<T>	Represents a constant scalar value.
class	ObservableLift<R,T>	Allows lifting operators into a chain of Observables.
class	ObservableMap<T,U>
class	ObservableMapNotification<T,R>
class	ObservableMaterialize<T>
class	ObservableMergeWithCompletable<T>	Merges an Observable and a Completable by emitting the items of the Observable and waiting until both the Observable and Completable complete normally.
class	ObservableMergeWithMaybe<T>	Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.
class	ObservableMergeWithSingle<T>	Merges an Observable and a Single by emitting the items of the Observable and the success value of the Single and waiting until both the Observable and Single terminate normally.
class	ObservableNever
class	ObservableObserveOn<T>
class	ObservableOnErrorComplete<T>	Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
class	ObservableOnErrorNext<T>
class	ObservableOnErrorReturn<T>
class	ObservablePublish<T>	Shares a single underlying connection to the upstream ObservableSource and multicasts events to all subscribed observers until the upstream completes or the connection is disposed.
class	ObservablePublishSelector<T,R>	Shares a source Observable for the duration of a selector function.
class	ObservableRange	Emits a range of integer values from start to end.
class	ObservableRangeLong
class	ObservableRefCount<T>	Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
class	ObservableRepeat<T>
class	ObservableRepeatUntil<T>
class	ObservableRepeatWhen<T>	Repeatedly subscribe to a source if a handler ObservableSource signals an item.
class	ObservableReplay<T>
(package private) static class	ObservableReplay.MulticastReplay<R,U>
(package private) static class	ObservableReplay.ReplaySource<T>
class	ObservableRetryBiPredicate<T>
class	ObservableRetryPredicate<T>
class	ObservableRetryWhen<T>	Repeatedly subscribe to a source if a handler ObservableSource signals an item.
class	ObservableSampleTimed<T>
class	ObservableSampleWithObservable<T>
(package private) static class	ObservableScalarXMap.ScalarXMapObservable<T,R>	Maps a scalar value to an ObservableSource and subscribes to it.
class	ObservableScan<T>
class	ObservableScanSeed<T,R>
class	ObservableSequenceEqual<T>
class	ObservableSerialized<T>
class	ObservableSkip<T>
class	ObservableSkipLast<T>
class	ObservableSkipLastTimed<T>
class	ObservableSkipUntil<T,U>
class	ObservableSkipWhile<T>
class	ObservableSubscribeOn<T>
class	ObservableSwitchIfEmpty<T>
class	ObservableSwitchMap<T,R>
class	ObservableTake<T>
class	ObservableTakeLast<T>
class	ObservableTakeLastOne<T>
class	ObservableTakeLastTimed<T>
class	ObservableTakeUntil<T,U>
class	ObservableTakeUntilPredicate<T>
class	ObservableTakeWhile<T>
class	ObservableThrottleFirstTimed<T>
class	ObservableThrottleLatest<T>	Emits the next or latest item when the given time elapses.
class	ObservableTimeInterval<T>
class	ObservableTimeout<T,U,V>
class	ObservableTimeoutTimed<T>
class	ObservableTimer
class	ObservableToList<T,U extends java.util.Collection<? super T>>
class	ObservableUnsubscribeOn<T>
class	ObservableUsing<T,D>
class	ObservableWindow<T>
class	ObservableWindowBoundary<T,B>
class	ObservableWindowBoundarySelector<T,B,V>
(package private) static class	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.WindowEndObserverIntercept<T,V>
(package private) class	ObservableWindowSubscribeIntercept<T>	Wrapper for a Subject that detects an incoming subscriber.
class	ObservableWindowTimed<T>
class	ObservableWithLatestFrom<T,U,R>
class	ObservableWithLatestFromMany<T,R>	Combines a main sequence of values with the latest from multiple other sequences via a selector function.
class	ObservableZip<T,R>
class	ObservableZipIterable<T,U,V>

Fields in io.reactivex.rxjava3.internal.operators.observable declared as ObservableSource

Modifier and Type	Field	Description
(package private) ObservableSource<B>	ObservableBufferExactBoundary.boundary
(package private) ObservableSource<B>	ObservableBufferExactBoundary.BufferExactBoundaryObserver.boundary
(package private) ObservableSource<? extends Open>	ObservableBufferBoundary.BufferBoundaryObserver.bufferOpen
(package private) ObservableSource<? extends Open>	ObservableBufferBoundary.bufferOpen
(package private) ObservableSource<? extends T>	ObservableTimeout.TimeoutFallbackObserver.fallback
(package private) ObservableSource<? extends T>	ObservableTimeoutTimed.TimeoutFallbackObserver.fallback
(package private) ObservableSource<? extends T>	ObservableSequenceEqual.EqualCoordinator.first
(package private) ObservableSource<? extends T>	ObservableSequenceEqual.first
(package private) ObservableSource<? extends T>	ObservableSequenceEqualSingle.EqualCoordinator.first
(package private) ObservableSource<? extends T>	ObservableSequenceEqualSingle.first
(package private) ObservableSource<U>	ObservableTimeout.firstTimeoutIndicator
private ObservableSource<T>	BlockingObservableNext.NextIterator.items
(package private) ObservableSource<? extends T>	ObservableDelaySubscriptionOther.main
(package private) ObservableSource<T>	ObservableReplay.onSubscribe
(package private) ObservableSource<B>	ObservableWindowBoundarySelector.open
(package private) ObservableSource<B>	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.open
(package private) ObservableSource<U>	ObservableDelaySubscriptionOther.other
(package private) ObservableSource<? extends TRight>	ObservableGroupJoin.other
(package private) ObservableSource<? extends TRight>	ObservableJoin.other
(package private) ObservableSource<?>	ObservableSampleWithObservable.other
(package private) ObservableSource<U>	ObservableSkipUntil.other
(package private) ObservableSource<? extends T>	ObservableSwitchIfEmpty.other
(package private) ObservableSource<? extends T>	ObservableSwitchIfEmpty.SwitchIfEmptyObserver.other
(package private) ObservableSource<? extends U>	ObservableTakeUntil.other
(package private) ObservableSource<? extends T>	ObservableTimeout.other
(package private) ObservableSource<? extends T>	ObservableTimeoutTimed.other
(package private) ObservableSource<B>	ObservableWindowBoundary.other
(package private) ObservableSource<? extends U>	ObservableWithLatestFrom.other
(package private) @Nullable ObservableSource<?>[]	ObservableWithLatestFromMany.otherArray
(package private) ObservableSource<?>	ObservableSampleWithObservable.SampleMainObserver.sampler
(package private) ObservableSource<? extends T>	ObservableSequenceEqual.EqualCoordinator.second
(package private) ObservableSource<? extends T>	ObservableSequenceEqual.second
(package private) ObservableSource<? extends T>	ObservableSequenceEqualSingle.EqualCoordinator.second
(package private) ObservableSource<? extends T>	ObservableSequenceEqualSingle.second
protected ObservableSource<T>	AbstractObservableWithUpstream.source	The source consumable Observable.
(package private) ObservableSource<? extends T>	BlockingObservableIterable.source
(package private) ObservableSource<T>	BlockingObservableLatest.source
(package private) ObservableSource<T>	BlockingObservableMostRecent.source
(package private) ObservableSource<T>	BlockingObservableNext.source
(package private) ObservableSource<T>	ObservableAllSingle.source
(package private) ObservableSource<T>	ObservableAnySingle.source
(package private) ObservableSource<T>	ObservableCollectSingle.source
(package private) ObservableSource<T>	ObservableCountSingle.source
(package private) ObservableSource<T>	ObservableElementAtMaybe.source
(package private) ObservableSource<T>	ObservableElementAtSingle.source
(package private) ObservableSource<T>	ObservableFlatMapCompletableCompletable.source
(package private) ObservableSource<T>	ObservableFromUnsafeSource.source
(package private) ObservableSource<T>	ObservableIgnoreElementsCompletable.source
(package private) ObservableSource<T>	ObservableLastMaybe.source
(package private) ObservableSource<T>	ObservableLastSingle.source
(package private) ObservableSource<T>	ObservablePublish.source
(package private) ObservableSource<T>	ObservableReduceMaybe.source
(package private) ObservableSource<T>	ObservableReduceSeedSingle.source
(package private) ObservableSource<T>	ObservableReduceWithSingle.source
(package private) ObservableSource<? extends T>	ObservableRepeat.RepeatObserver.source
(package private) ObservableSource<? extends T>	ObservableRepeatUntil.RepeatUntilObserver.source
(package private) ObservableSource<T>	ObservableRepeatWhen.RepeatWhenObserver.source
(package private) ObservableSource<T>	ObservableReplay.source	The source observable.
(package private) ObservableSource<? extends T>	ObservableRetryBiPredicate.RetryBiObserver.source
(package private) ObservableSource<? extends T>	ObservableRetryPredicate.RepeatObserver.source
(package private) ObservableSource<T>	ObservableRetryWhen.RepeatWhenObserver.source
(package private) ObservableSource<T>	ObservableSingleMaybe.source
(package private) ObservableSource<? extends T>	ObservableSingleSingle.source
(package private) ObservableSource<T>	ObservableToListSingle.source
(package private) ObservableSource<? extends T>[]	ObservableAmb.sources
(package private) ObservableSource<? extends T>[]	ObservableCombineLatest.sources
(package private) ObservableSource<? extends T>[]	ObservableZip.sources

Fields in io.reactivex.rxjava3.internal.operators.observable with type parameters of type ObservableSource

Modifier and Type	Field	Description
(package private) Function<? super Open,? extends ObservableSource<? extends Close>>	ObservableBufferBoundary.BufferBoundaryObserver.bufferClose
(package private) Function<? super Open,? extends ObservableSource<? extends Close>>	ObservableBufferBoundary.bufferClose
(package private) Function<? super B,? extends ObservableSource<V>>	ObservableWindowBoundarySelector.closingIndicator
(package private) Function<? super B,? extends ObservableSource<V>>	ObservableWindowBoundarySelector.WindowBoundaryMainObserver.closingIndicator
(package private) Function<? super T,? extends ObservableSource<U>>	ObservableDebounce.DebounceObserver.debounceSelector
(package private) Function<? super T,? extends ObservableSource<U>>	ObservableDebounce.debounceSelector
(package private) Observer<? super ObservableSource<? extends R>>	ObservableMapNotification.MapNotificationObserver.downstream
(package private) Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>>	ObservableRepeatWhen.handler
(package private) Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>>	ObservableRetryWhen.handler
(package private) Function<? super T,? extends ObservableSource<U>>	ObservableInternalHelper.ItemDelayFunction.itemDelay
(package private) Function<? super T,? extends ObservableSource<V>>	ObservableTimeout.itemTimeoutIndicator
(package private) Function<? super T,? extends ObservableSource<?>>	ObservableTimeout.TimeoutFallbackObserver.itemTimeoutIndicator
(package private) Function<? super T,? extends ObservableSource<?>>	ObservableTimeout.TimeoutObserver.itemTimeoutIndicator
(package private) Function<? super TLeft,? extends ObservableSource<TLeftEnd>>	ObservableGroupJoin.GroupJoinDisposable.leftEnd
(package private) Function<? super TLeft,? extends ObservableSource<TLeftEnd>>	ObservableGroupJoin.leftEnd
(package private) Function<? super TLeft,? extends ObservableSource<TLeftEnd>>	ObservableJoin.JoinDisposable.leftEnd
(package private) Function<? super TLeft,? extends ObservableSource<TLeftEnd>>	ObservableJoin.leftEnd
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableConcatMap.ConcatMapDelayErrorObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends U>>	ObservableConcatMap.mapper
(package private) Function<? super T,? extends ObservableSource<? extends U>>	ObservableConcatMap.SourceObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableConcatMapEager.ConcatMapEagerMainObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableConcatMapEager.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableConcatMapScheduler.ConcatMapDelayErrorObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends U>>	ObservableConcatMapScheduler.ConcatMapObserver.mapper
(package private) Function<? super T,? extends ObservableSource<? extends U>>	ObservableConcatMapScheduler.mapper
(package private) Function<? super T,? extends ObservableSource<? extends U>>	ObservableFlatMap.mapper
(package private) Function<? super T,? extends ObservableSource<? extends U>>	ObservableFlatMap.MergeObserver.mapper
private Function<? super T,? extends ObservableSource<? extends U>>	ObservableInternalHelper.FlatMapWithCombinerOuter.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableScalarXMap.ScalarXMapObservable.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableSwitchMap.mapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableSwitchMap.SwitchMapObserver.mapper
(package private) Function<? super java.lang.Throwable,? extends ObservableSource<? extends T>>	ObservableOnErrorNext.nextSupplier
(package private) Function<? super java.lang.Throwable,? extends ObservableSource<? extends T>>	ObservableOnErrorNext.OnErrorNextObserver.nextSupplier
(package private) Supplier<? extends ObservableSource<? extends R>>	ObservableMapNotification.MapNotificationObserver.onCompleteSupplier
(package private) Supplier<? extends ObservableSource<? extends R>>	ObservableMapNotification.onCompleteSupplier
(package private) Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>>	ObservableMapNotification.MapNotificationObserver.onErrorMapper
(package private) Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>>	ObservableMapNotification.onErrorMapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableMapNotification.MapNotificationObserver.onNextMapper
(package private) Function<? super T,? extends ObservableSource<? extends R>>	ObservableMapNotification.onNextMapper
(package private) @Nullable java.lang.Iterable<? extends ObservableSource<?>>	ObservableWithLatestFromMany.otherIterable
(package private) Function<? super TRight,? extends ObservableSource<TRightEnd>>	ObservableGroupJoin.GroupJoinDisposable.rightEnd
(package private) Function<? super TRight,? extends ObservableSource<TRightEnd>>	ObservableGroupJoin.rightEnd
(package private) Function<? super TRight,? extends ObservableSource<TRightEnd>>	ObservableJoin.JoinDisposable.rightEnd
(package private) Function<? super TRight,? extends ObservableSource<TRightEnd>>	ObservableJoin.rightEnd
(package private) Function<? super Observable<T>,? extends ObservableSource<R>>	ObservablePublishSelector.selector
private Function<? super Observable<U>,? extends ObservableSource<R>>	ObservableReplay.MulticastReplay.selector
(package private) java.util.Queue<ObservableSource<? extends U>>	ObservableFlatMap.MergeObserver.sources
(package private) java.lang.Iterable<? extends ObservableSource<? extends T>>	ObservableAmb.sourcesIterable
(package private) java.lang.Iterable<? extends ObservableSource<? extends T>>	ObservableCombineLatest.sourcesIterable
(package private) java.lang.Iterable<? extends ObservableSource<? extends T>>	ObservableZip.sourcesIterable
(package private) Function<? super D,? extends ObservableSource<? extends T>>	ObservableUsing.sourceSupplier
(package private) Supplier<? extends ObservableSource<? extends T>>	ObservableDefer.supplier

Methods in io.reactivex.rxjava3.internal.operators.observable that return ObservableSource

Modifier and Type	Method	Description
ObservableSource<U>	ObservableInternalHelper.FlatMapIntoIterable.apply(T t)
ObservableSource<R>	ObservableInternalHelper.FlatMapWithCombinerOuter.apply(T t)
ObservableSource<T>	ObservableInternalHelper.ItemDelayFunction.apply(T v)
ObservableSource<T>	AbstractObservableWithUpstream.source()
ObservableSource<T>	ObservablePublish.source()
ObservableSource<T>	ObservableReplay.source()

Methods in io.reactivex.rxjava3.internal.operators.observable that return types with arguments of type ObservableSource

Modifier and Type	Method	Description
static <T,U> Function<T,ObservableSource<U>>	ObservableInternalHelper.flatMapIntoIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
static <T,U,R> Function<T,ObservableSource<R>>	ObservableInternalHelper.flatMapWithCombiner(Function<? super T,? extends ObservableSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner)
static <T,U> Function<T,ObservableSource<T>>	ObservableInternalHelper.itemDelay(Function<? super T,? extends ObservableSource<U>> itemDelay)

Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type ObservableSource

Modifier and Type	Method	Description
static <T> ConnectableObservable<T>	ObservableReplay.create(ObservableSource<T> source, int bufferSize, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a size bound buffer.
static <T> ConnectableObservable<T>	ObservableReplay.create(ObservableSource<T> source, long maxAge, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a time bound buffer.
static <T> ConnectableObservable<T>	ObservableReplay.create(ObservableSource<T> source, long maxAge, java.util.concurrent.TimeUnit unit, Scheduler scheduler, int bufferSize, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a size and time bound buffer.
(package private) static <T> ConnectableObservable<T>	ObservableReplay.create(ObservableSource<T> source, ObservableReplay.BufferSupplier<T> bufferFactory)	Creates a OperatorReplay instance to replay values of the given source observable.
static <T> ConnectableObservable<T>	ObservableReplay.createFrom(ObservableSource<? extends T> source)	Creates a replaying ConnectableObservable with an unbounded buffer.
(package private) void	ObservableTimeout.TimeoutFallbackObserver.startFirstTimeout(ObservableSource<?> firstTimeoutIndicator)
(package private) void	ObservableTimeout.TimeoutObserver.startFirstTimeout(ObservableSource<?> firstTimeoutIndicator)
void	ObservableAmb.AmbCoordinator.subscribe(ObservableSource<? extends T>[] sources)
static <T> void	ObservableBlockingSubscribe.subscribe(ObservableSource<? extends T> o)	Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
static <T> void	ObservableBlockingSubscribe.subscribe(ObservableSource<? extends T> o, Observer<? super T> observer)	Subscribes to the source and calls the Observer methods on the current thread.
static <T> void	ObservableBlockingSubscribe.subscribe(ObservableSource<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Subscribes to the source and calls the given actions on the current thread.
void	ObservableCombineLatest.LatestCoordinator.subscribe(ObservableSource<? extends T>[] sources)
(package private) void	ObservableWithLatestFromMany.WithLatestFromObserver.subscribe(ObservableSource<?>[] others, int n)
void	ObservableZip.ZipCoordinator.subscribe(ObservableSource<? extends T>[] sources, int bufferSize)
(package private) void	ObservableFlatMap.MergeObserver.subscribeInner(ObservableSource<? extends U> p)
static <T,R> boolean	ObservableScalarXMap.tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T,? extends ObservableSource<? extends R>> mapper)	Tries to subscribe to a possibly Supplier source's mapped ObservableSource.

Method parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type ObservableSource

Modifier and Type	Method	Description
static <T,U,R> Function<T,ObservableSource<R>>	ObservableInternalHelper.flatMapWithCombiner(Function<? super T,? extends ObservableSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> combiner)
static <T,U> Function<T,ObservableSource<T>>	ObservableInternalHelper.itemDelay(Function<? super T,? extends ObservableSource<U>> itemDelay)
static <U,R> Observable<R>	ObservableReplay.multicastSelector(Supplier<? extends ConnectableObservable<U>> connectableFactory, Function<? super Observable<U>,? extends ObservableSource<R>> selector)	Given a connectable observable factory, it multicasts over the generated ConnectableObservable via a selector function.
static <T,U> Observable<U>	ObservableScalarXMap.scalarXMap(T value, Function<? super T,? extends ObservableSource<? extends U>> mapper)	Maps a scalar value into an Observable and emits its values.
void	ObservableMapNotification.subscribeActual(Observer<? super ObservableSource<? extends R>> t)
static <T,R> boolean	ObservableScalarXMap.tryScalarXMapSubscribe(ObservableSource<T> source, Observer<? super R> observer, Function<? super T,? extends ObservableSource<? extends R>> mapper)	Tries to subscribe to a possibly Supplier source's mapped ObservableSource.

Constructors in io.reactivex.rxjava3.internal.operators.observable with parameters of type ObservableSource

Constructor	Description
AbstractObservableWithUpstream(ObservableSource<T> source)	Constructs the ObservableSource with the given consumable.
BlockingObservableIterable(ObservableSource<? extends T> source, int bufferSize)
BlockingObservableLatest(ObservableSource<T> source)
BlockingObservableMostRecent(ObservableSource<T> source, T initialValue)
BlockingObservableNext(ObservableSource<T> source)
BufferBoundaryObserver(Observer<? super C> actual, ObservableSource<? extends Open> bufferOpen, Function<? super Open,? extends ObservableSource<? extends Close>> bufferClose, Supplier<C> bufferSupplier)
BufferExactBoundaryObserver(Observer<? super U> actual, Supplier<U> bufferSupplier, ObservableSource<B> boundary)
EqualCoordinator(Observer<? super java.lang.Boolean> actual, int bufferSize, ObservableSource<? extends T> first, ObservableSource<? extends T> second, BiPredicate<? super T,? super T> comparer)
EqualCoordinator(SingleObserver<? super java.lang.Boolean> actual, int bufferSize, ObservableSource<? extends T> first, ObservableSource<? extends T> second, BiPredicate<? super T,? super T> comparer)
NextIterator(ObservableSource<T> items, BlockingObservableNext.NextObserver<T> observer)
ObservableAll(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableAllSingle(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableAmb(ObservableSource<? extends T>[] sources, java.lang.Iterable<? extends ObservableSource<? extends T>> sourcesIterable)
ObservableAny(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableAnySingle(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableBuffer(ObservableSource<T> source, int count, int skip, Supplier<U> bufferSupplier)
ObservableBufferBoundary(ObservableSource<T> source, ObservableSource<? extends Open> bufferOpen, Function<? super Open,? extends ObservableSource<? extends Close>> bufferClose, Supplier<U> bufferSupplier)
ObservableBufferExactBoundary(ObservableSource<T> source, ObservableSource<B> boundary, Supplier<U> bufferSupplier)
ObservableBufferTimed(ObservableSource<T> source, long timespan, long timeskip, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Supplier<U> bufferSupplier, int maxSize, boolean restartTimerOnMaxSize)
ObservableCollect(ObservableSource<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U,? super T> collector)
ObservableCollectSingle(ObservableSource<T> source, Supplier<? extends U> initialSupplier, BiConsumer<? super U,? super T> collector)
ObservableCombineLatest(ObservableSource<? extends T>[] sources, java.lang.Iterable<? extends ObservableSource<? extends T>> sourcesIterable, Function<? super java.lang.Object[],? extends R> combiner, int bufferSize, boolean delayError)
ObservableConcatMap(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors)
ObservableConcatMapEager(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper, ErrorMode errorMode, int maxConcurrency, int prefetch)
ObservableConcatMapScheduler(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors, Scheduler scheduler)
ObservableCount(ObservableSource<T> source)
ObservableCountSingle(ObservableSource<T> source)
ObservableDebounce(ObservableSource<T> source, Function<? super T,? extends ObservableSource<U>> debounceSelector)
ObservableDebounceTimed(ObservableSource<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
ObservableDelay(ObservableSource<T> source, long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
ObservableDelaySubscriptionOther(ObservableSource<? extends T> main, ObservableSource<U> other)
ObservableDematerialize(ObservableSource<T> source, Function<? super T,? extends Notification<R>> selector)
ObservableDetach(ObservableSource<T> source)
ObservableDistinct(ObservableSource<T> source, Function<? super T,K> keySelector, Supplier<? extends java.util.Collection<? super K>> collectionSupplier)
ObservableDistinctUntilChanged(ObservableSource<T> source, Function<? super T,K> keySelector, BiPredicate<? super K,? super K> comparer)
ObservableDoAfterNext(ObservableSource<T> source, Consumer<? super T> onAfterNext)
ObservableDoFinally(ObservableSource<T> source, Action onFinally)
ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
ObservableElementAt(ObservableSource<T> source, long index, T defaultValue, boolean errorOnFewer)
ObservableElementAtMaybe(ObservableSource<T> source, long index)
ObservableElementAtSingle(ObservableSource<T> source, long index, T defaultValue)
ObservableFilter(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableFlatMap(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
ObservableFlatMapCompletable(ObservableSource<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
ObservableFlatMapCompletableCompletable(ObservableSource<T> source, Function<? super T,? extends CompletableSource> mapper, boolean delayErrors)
ObservableFlatMapMaybe(ObservableSource<T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper, boolean delayError)
ObservableFlatMapSingle(ObservableSource<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayError)
ObservableFlattenIterable(ObservableSource<T> source, Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
ObservableFromUnsafeSource(ObservableSource<T> source)
ObservableGroupBy(ObservableSource<T> source, Function<? super T,? extends K> keySelector, Function<? super T,? extends V> valueSelector, int bufferSize, boolean delayError)
ObservableGroupJoin(ObservableSource<TLeft> source, ObservableSource<? extends TRight> other, Function<? super TLeft,? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super Observable<TRight>,? extends R> resultSelector)
ObservableHide(ObservableSource<T> source)
ObservableIgnoreElements(ObservableSource<T> source)
ObservableIgnoreElementsCompletable(ObservableSource<T> source)
ObservableJoin(ObservableSource<TLeft> source, ObservableSource<? extends TRight> other, Function<? super TLeft,? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super TRight,? extends R> resultSelector)
ObservableLastMaybe(ObservableSource<T> source)
ObservableLastSingle(ObservableSource<T> source, T defaultItem)
ObservableLift(ObservableSource<T> source, ObservableOperator<? extends R,? super T> operator)
ObservableMap(ObservableSource<T> source, Function<? super T,? extends U> function)
ObservableMapNotification(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
ObservableMaterialize(ObservableSource<T> source)
ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize)
ObservableOnErrorComplete(ObservableSource<T> source, Predicate<? super java.lang.Throwable> predicate)
ObservableOnErrorNext(ObservableSource<T> source, Function<? super java.lang.Throwable,? extends ObservableSource<? extends T>> nextSupplier)
ObservableOnErrorReturn(ObservableSource<T> source, Function<? super java.lang.Throwable,? extends T> valueSupplier)
ObservablePublish(ObservableSource<T> source)
ObservablePublishSelector(ObservableSource<T> source, Function<? super Observable<T>,? extends ObservableSource<R>> selector)
ObservableReduceMaybe(ObservableSource<T> source, BiFunction<T,T,T> reducer)
ObservableReduceSeedSingle(ObservableSource<T> source, R seed, BiFunction<R,? super T,R> reducer)
ObservableReduceWithSingle(ObservableSource<T> source, Supplier<R> seedSupplier, BiFunction<R,? super T,R> reducer)
ObservableRepeatWhen(ObservableSource<T> source, Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>> handler)
ObservableReplay(ObservableSource<T> onSubscribe, ObservableSource<T> source, java.util.concurrent.atomic.AtomicReference<ObservableReplay.ReplayObserver<T>> current, ObservableReplay.BufferSupplier<T> bufferFactory)
ObservableRetryWhen(ObservableSource<T> source, Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>> handler)
ObservableSampleTimed(ObservableSource<T> source, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
ObservableSampleWithObservable(ObservableSource<T> source, ObservableSource<?> other, boolean emitLast)
ObservableScan(ObservableSource<T> source, BiFunction<T,T,T> accumulator)
ObservableScanSeed(ObservableSource<T> source, Supplier<R> seedSupplier, BiFunction<R,? super T,R> accumulator)
ObservableSequenceEqual(ObservableSource<? extends T> first, ObservableSource<? extends T> second, BiPredicate<? super T,? super T> comparer, int bufferSize)
ObservableSequenceEqualSingle(ObservableSource<? extends T> first, ObservableSource<? extends T> second, BiPredicate<? super T,? super T> comparer, int bufferSize)
ObservableSingleMaybe(ObservableSource<T> source)
ObservableSingleSingle(ObservableSource<? extends T> source, T defaultValue)
ObservableSkip(ObservableSource<T> source, long n)
ObservableSkipLast(ObservableSource<T> source, int skip)
ObservableSkipLastTimed(ObservableSource<T> source, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
ObservableSkipUntil(ObservableSource<T> source, ObservableSource<U> other)
ObservableSkipWhile(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler)
ObservableSwitchIfEmpty(ObservableSource<T> source, ObservableSource<? extends T> other)
ObservableSwitchMap(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean delayErrors)
ObservableTake(ObservableSource<T> source, long limit)
ObservableTakeLast(ObservableSource<T> source, int count)
ObservableTakeLastOne(ObservableSource<T> source)
ObservableTakeLastTimed(ObservableSource<T> source, long count, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
ObservableTakeUntil(ObservableSource<T> source, ObservableSource<? extends U> other)
ObservableTakeUntilPredicate(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableTakeWhile(ObservableSource<T> source, Predicate<? super T> predicate)
ObservableThrottleFirstTimed(ObservableSource<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
ObservableTimeInterval(ObservableSource<T> source, java.util.concurrent.TimeUnit unit, Scheduler scheduler)
ObservableTimeout(Observable<T> source, ObservableSource<U> firstTimeoutIndicator, Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)
ObservableTimeoutTimed(Observable<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, ObservableSource<? extends T> other)
ObservableToList(ObservableSource<T> source, Supplier<U> collectionSupplier)
ObservableToListSingle(ObservableSource<T> source, int defaultCapacityHint)
ObservableToListSingle(ObservableSource<T> source, Supplier<U> collectionSupplier)
ObservableUnsubscribeOn(ObservableSource<T> source, Scheduler scheduler)
ObservableWindow(ObservableSource<T> source, long count, long skip, int capacityHint)
ObservableWindowBoundary(ObservableSource<T> source, ObservableSource<B> other, int capacityHint)
ObservableWindowBoundarySelector(ObservableSource<T> source, ObservableSource<B> open, Function<? super B,? extends ObservableSource<V>> closingIndicator, int bufferSize)
ObservableWithLatestFrom(ObservableSource<T> source, BiFunction<? super T,? super U,? extends R> combiner, ObservableSource<? extends U> other)
ObservableWithLatestFromMany(@NonNull ObservableSource<T> source, @NonNull ObservableSource<?>[] otherArray, @NonNull Function<? super java.lang.Object[],R> combiner)
ObservableWithLatestFromMany(@NonNull ObservableSource<T> source, @NonNull java.lang.Iterable<? extends ObservableSource<?>> otherIterable, @NonNull Function<? super java.lang.Object[],R> combiner)
ObservableZip(ObservableSource<? extends T>[] sources, java.lang.Iterable<? extends ObservableSource<? extends T>> sourcesIterable, Function<? super java.lang.Object[],? extends R> zipper, int bufferSize, boolean delayError)
RepeatObserver(Observer<? super T> actual, long count, SequentialDisposable sd, ObservableSource<? extends T> source)
RepeatObserver(Observer<? super T> actual, long count, Predicate<? super java.lang.Throwable> predicate, SequentialDisposable sa, ObservableSource<? extends T> source)
RepeatUntilObserver(Observer<? super T> actual, BooleanSupplier until, SequentialDisposable sd, ObservableSource<? extends T> source)
RepeatWhenObserver(Observer<? super T> actual, Subject<java.lang.Object> signaller, ObservableSource<T> source)
RepeatWhenObserver(Observer<? super T> actual, Subject<java.lang.Throwable> signaller, ObservableSource<T> source)
RetryBiObserver(Observer<? super T> actual, BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate, SequentialDisposable sa, ObservableSource<? extends T> source)
SampleMainEmitLast(Observer<? super T> actual, ObservableSource<?> other)
SampleMainNoLast(Observer<? super T> actual, ObservableSource<?> other)
SampleMainObserver(Observer<? super T> actual, ObservableSource<?> other)
SwitchIfEmptyObserver(Observer<? super T> actual, ObservableSource<? extends T> other)
TimeoutFallbackObserver(Observer<? super T> actual, Function<? super T,? extends ObservableSource<?>> itemTimeoutIndicator, ObservableSource<? extends T> fallback)
TimeoutFallbackObserver(Observer<? super T> actual, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, ObservableSource<? extends T> fallback)
WindowBoundaryMainObserver(Observer<? super Observable<T>> downstream, ObservableSource<B> open, Function<? super B,? extends ObservableSource<V>> closingIndicator, int bufferSize)

Constructor parameters in io.reactivex.rxjava3.internal.operators.observable with type arguments of type ObservableSource

Constructor	Description
BufferBoundaryObserver(Observer<? super C> actual, ObservableSource<? extends Open> bufferOpen, Function<? super Open,? extends ObservableSource<? extends Close>> bufferClose, Supplier<C> bufferSupplier)
ConcatMapDelayErrorObserver(Observer<? super R> actual, Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean tillTheEnd)
ConcatMapDelayErrorObserver(Observer<? super R> actual, Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean tillTheEnd, Scheduler.Worker worker)
ConcatMapEagerMainObserver(Observer<? super R> actual, Function<? super T,? extends ObservableSource<? extends R>> mapper, int maxConcurrency, int prefetch, ErrorMode errorMode)
ConcatMapObserver(Observer<? super U> actual, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize, Scheduler.Worker worker)
DebounceObserver(Observer<? super T> actual, Function<? super T,? extends ObservableSource<U>> debounceSelector)
FlatMapWithCombinerOuter(BiFunction<? super T,? super U,? extends R> combiner, Function<? super T,? extends ObservableSource<? extends U>> mapper)
GroupJoinDisposable(Observer<? super R> actual, Function<? super TLeft,? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super Observable<TRight>,? extends R> resultSelector)
ItemDelayFunction(Function<? super T,? extends ObservableSource<U>> itemDelay)
JoinDisposable(Observer<? super R> actual, Function<? super TLeft,? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super TRight,? extends R> resultSelector)
MapNotificationObserver(Observer<? super ObservableSource<? extends R>> actual, Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
MapNotificationObserver(Observer<? super ObservableSource<? extends R>> actual, Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
MapNotificationObserver(Observer<? super ObservableSource<? extends R>> actual, Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
MergeObserver(Observer<? super U> actual, Function<? super T,? extends ObservableSource<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
MulticastReplay(Supplier<? extends ConnectableObservable<U>> connectableFactory, Function<? super Observable<U>,? extends ObservableSource<R>> selector)
ObservableAmb(ObservableSource<? extends T>[] sources, java.lang.Iterable<? extends ObservableSource<? extends T>> sourcesIterable)
ObservableBufferBoundary(ObservableSource<T> source, ObservableSource<? extends Open> bufferOpen, Function<? super Open,? extends ObservableSource<? extends Close>> bufferClose, Supplier<U> bufferSupplier)
ObservableCombineLatest(ObservableSource<? extends T>[] sources, java.lang.Iterable<? extends ObservableSource<? extends T>> sourcesIterable, Function<? super java.lang.Object[],? extends R> combiner, int bufferSize, boolean delayError)
ObservableConcatMap(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors)
ObservableConcatMapEager(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper, ErrorMode errorMode, int maxConcurrency, int prefetch)
ObservableConcatMapScheduler(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors, Scheduler scheduler)
ObservableDebounce(ObservableSource<T> source, Function<? super T,? extends ObservableSource<U>> debounceSelector)
ObservableDefer(Supplier<? extends ObservableSource<? extends T>> supplier)
ObservableFlatMap(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, boolean delayErrors, int maxConcurrency, int bufferSize)
ObservableGroupJoin(ObservableSource<TLeft> source, ObservableSource<? extends TRight> other, Function<? super TLeft,? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super Observable<TRight>,? extends R> resultSelector)
ObservableJoin(ObservableSource<TLeft> source, ObservableSource<? extends TRight> other, Function<? super TLeft,? extends ObservableSource<TLeftEnd>> leftEnd, Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd, BiFunction<? super TLeft,? super TRight,? extends R> resultSelector)
ObservableMapNotification(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
ObservableMapNotification(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> onNextMapper, Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper, Supplier<? extends ObservableSource<? extends R>> onCompleteSupplier)
ObservableOnErrorNext(ObservableSource<T> source, Function<? super java.lang.Throwable,? extends ObservableSource<? extends T>> nextSupplier)
ObservablePublishSelector(ObservableSource<T> source, Function<? super Observable<T>,? extends ObservableSource<R>> selector)
ObservableRepeatWhen(ObservableSource<T> source, Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>> handler)
ObservableRetryWhen(ObservableSource<T> source, Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>> handler)
ObservableSwitchMap(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean delayErrors)
ObservableTimeout(Observable<T> source, ObservableSource<U> firstTimeoutIndicator, Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator, ObservableSource<? extends T> other)
ObservableUsing(Supplier<? extends D> resourceSupplier, Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
ObservableWindowBoundarySelector(ObservableSource<T> source, ObservableSource<B> open, Function<? super B,? extends ObservableSource<V>> closingIndicator, int bufferSize)
ObservableWithLatestFromMany(@NonNull ObservableSource<T> source, @NonNull java.lang.Iterable<? extends ObservableSource<?>> otherIterable, @NonNull Function<? super java.lang.Object[],R> combiner)
ObservableZip(ObservableSource<? extends T>[] sources, java.lang.Iterable<? extends ObservableSource<? extends T>> sourcesIterable, Function<? super java.lang.Object[],? extends R> zipper, int bufferSize, boolean delayError)
OnErrorNextObserver(Observer<? super T> actual, Function<? super java.lang.Throwable,? extends ObservableSource<? extends T>> nextSupplier)
ScalarXMapObservable(T value, Function<? super T,? extends ObservableSource<? extends R>> mapper)
SourceObserver(Observer<? super U> actual, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize)
SwitchMapObserver(Observer<? super R> actual, Function<? super T,? extends ObservableSource<? extends R>> mapper, int bufferSize, boolean delayErrors)
TimeoutFallbackObserver(Observer<? super T> actual, Function<? super T,? extends ObservableSource<?>> itemTimeoutIndicator, ObservableSource<? extends T> fallback)
TimeoutObserver(Observer<? super T> actual, Function<? super T,? extends ObservableSource<?>> itemTimeoutIndicator)
WindowBoundaryMainObserver(Observer<? super Observable<T>> downstream, ObservableSource<B> open, Function<? super B,? extends ObservableSource<V>> closingIndicator, int bufferSize)

Uses of ObservableSource in io.reactivex.rxjava3.internal.operators.single

Classes in io.reactivex.rxjava3.internal.operators.single that implement ObservableSource

Modifier and Type	Class	Description
class	SingleFlatMapIterableObservable<T,R>	Maps a success value into an Iterable and streams it back as an Observable.
class	SingleToObservable<T>	Wraps a Single and exposes it as an Observable.

Fields in io.reactivex.rxjava3.internal.operators.single declared as ObservableSource

Modifier and Type	Field	Description
(package private) ObservableSource<U>	SingleDelayWithObservable.other

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type ObservableSource

Constructor	Description
SingleDelayWithObservable(SingleSource<T> source, ObservableSource<U> other)

Uses of ObservableSource in io.reactivex.rxjava3.observables

Classes in io.reactivex.rxjava3.observables that implement ObservableSource

Modifier and Type	Class	Description
class	ConnectableObservable<T>	A ConnectableObservable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableObservable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.
class	GroupedObservable<K,T>	An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().

Uses of ObservableSource in io.reactivex.rxjava3.subjects

Classes in io.reactivex.rxjava3.subjects that implement ObservableSource

Modifier and Type	Class	Description
class	AsyncSubject<T>	A Subject that emits the very last value followed by a completion event or the received error to Observers.
class	BehaviorSubject<T>	Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.
class	PublishSubject<T>	A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current or late Observers.
class	ReplaySubject<T>	Replays events (in a configurable bounded or unbounded manner) to current and late Observers.
(package private) class	SerializedSubject<T>	Serializes calls to the Observer methods.
class	Subject<T>	Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Observers.
class	UnicastSubject<T>	A Subject that queues up events until a single Observer subscribes to it, replays those events to it until the Observer catches up and then switches to relaying events live to this single Observer until this UnicastSubject terminates or the Observer disposes.