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

Packages that use SingleSource

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.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 SingleSource in io.reactivex.rxjava3.core

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

Modifier and Type	Class	Description
class	Single<T>	The Single class implements the Reactive Pattern for a single value response.

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

Modifier and Type	Method	Description
@NonNull SingleSource<Downstream>	SingleTransformer.apply(@NonNull Single<@NonNull Upstream> upstream)	Applies a function to the upstream Single and returns a SingleSource with optionally different element type.

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Single<T>	Single.ambArray(@NonNull SingleSource<? extends @NonNull T>... sources)	Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
@NonNull Single<T>	Single.ambWith(@NonNull SingleSource<? extends @NonNull T> other)	Signals the event of this or the other SingleSource whichever signals first.
<@NonNull T> @NonNull Single<T>	Completable.andThen(@NonNull SingleSource<@NonNull T> next)	Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next SingleSource.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArray(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArrayDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArrayEager(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Single.concatArrayEagerDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenates a sequence of SingleSource eagerly into a single stream of values.
@NonNull Flowable<T>	Flowable.concatWith(@NonNull SingleSource<? extends @NonNull T> other)	Returns a Flowable that emits the items from this Flowable followed by the success item or error event of the other SingleSource.
@NonNull Observable<T>	Observable.concatWith(@NonNull SingleSource<? extends @NonNull T> other)	Returns an Observable that emits the items from the current Observable followed by the success item or error event of the other SingleSource.
@NonNull Flowable<T>	Single.concatWith(@NonNull SingleSource<? extends @NonNull T> other)	Returns a Flowable that emits the item emitted by the current Single, then the item emitted by the specified SingleSource.
<@NonNull U> @NonNull Single<T>	Single.delaySubscription(@NonNull SingleSource<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other SingleSource signals success.
static <@NonNull T> @NonNull Completable	Completable.fromSingle(@NonNull SingleSource<@NonNull T> single)	Returns a Completable instance that when subscribed to, subscribes to the SingleSource instance and emits a completion event if the single emits onSuccess or forwards any onError events.
static <@NonNull T> @NonNull Flowable<T>	Flowable.fromSingle(@NonNull SingleSource<@NonNull T> source)	Returns a Flowable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.
static <@NonNull T> @NonNull Maybe<T>	Maybe.fromSingle(@NonNull SingleSource<@NonNull T> single)	Wraps a SingleSource into a Maybe.
static <@NonNull T> @NonNull Observable<T>	Observable.fromSingle(@NonNull SingleSource<@NonNull T> source)	Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.
static <@NonNull T> @NonNull Single<T>	Single.merge(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source)	Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item emitted by the nested SingleSource, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Flattens two SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Flattens three SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Flattens four SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeArray(SingleSource<? extends @NonNull T>... sources)	Merges an array of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeArrayDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Flattens an array of SingleSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source SingleSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
@NonNull Flowable<T>	Flowable.mergeWith(@NonNull SingleSource<? extends @NonNull T> other)	Merges the sequence of items of this Flowable with the success value of the other SingleSource.
@NonNull Observable<T>	Observable.mergeWith(@NonNull SingleSource<? extends @NonNull T> other)	Merges the sequence of items of the current Observable with the success value of the other SingleSource.
@NonNull Flowable<T>	Single.mergeWith(@NonNull SingleSource<? extends @NonNull T> other)	Flattens this Single and another SingleSource into one Flowable, without any transformation.
@NonNull Single<T>	Single.onErrorResumeWith(@NonNull SingleSource<? extends @NonNull T> fallback)	Resumes the flow with the given SingleSource when the current Single fails instead of signaling the error via onError.
static <@NonNull T> @NonNull Single<java.lang.Boolean>	Single.sequenceEqual(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).
<@NonNull T> @NonNull Flowable<T>	Completable.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Completable if the other succeeded normally.
@NonNull Flowable<T>	Flowable.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Flowable if the other succeeded normally.
@NonNull Flowable<T>	Maybe.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Maybe if the other succeeded normally.
@NonNull Observable<T>	Observable.startWith(@NonNull SingleSource<@NonNull T> other)	Returns an Observable which first runs the other SingleSource then the current Observable if the other succeeded normally.
@NonNull Flowable<T>	Single.startWith(@NonNull SingleSource<@NonNull T> other)	Returns a Flowable which first runs the other SingleSource then the current Single if the other succeeded normally.
@NonNull Single<T>	Maybe.switchIfEmpty(@NonNull SingleSource<? extends @NonNull T> other)	Returns a Single that emits the items emitted by the current Maybe or the item of an alternate SingleSource if the current Maybe is empty.
<@NonNull E> @NonNull Single<T>	Single.takeUntil(@NonNull SingleSource<? extends @NonNull E> other)	Returns a Single that emits the item emitted by the current Single until a second Single emits an item.
@NonNull Single<T>	Single.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback)	Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
@NonNull Single<T>	Single.timeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull SingleSource<? extends @NonNull T> fallback)	Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
private Single<T>	Single.timeout0(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, SingleSource<? extends @NonNull T> fallback)
static <@NonNull T> @NonNull Single<T>	Single.unsafeCreate(@NonNull SingleSource<@NonNull T> onSubscribe)	Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
static <@NonNull T> @NonNull Single<T>	Single.wrap(@NonNull SingleSource<@NonNull T> source)	Wraps a SingleSource instance into a new Single instance if not already a Single instance.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull T9,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull SingleSource<? extends @NonNull T8> source8, @NonNull SingleSource<? 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 a Single that emits the results of a specified combiner function applied to nine items emitted by nine other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull T8,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull SingleSource<? 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 a Single that emits the results of a specified combiner function applied to eight items emitted by eight other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull T7,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? 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 a Single that emits the results of a specified combiner function applied to seven items emitted by seven other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull T6,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? 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 a Single that emits the results of a specified combiner function applied to six items emitted by six other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull T5,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? 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 a Single that emits the results of a specified combiner function applied to five items emitted by five other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull T4,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? super @NonNull T4,? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull T3,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1,? super @NonNull T2,? super @NonNull T3,? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other SingleSources.
static <@NonNull T1,@NonNull T2,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1,? super @NonNull T2,? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other SingleSources.
static <@NonNull T,@NonNull R> @NonNull Single<R>	Single.zipArray(@NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull T>... sources)	Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
<@NonNull U,@NonNull R> @NonNull Single<R>	Single.zipWith(@NonNull SingleSource<@NonNull U> other, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> zipper)	Returns a Single that emits the result of applying a specified function to the pair of items emitted by the current Single and another specified SingleSource.

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Single<T>	Single.amb(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
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 Flowable<T>	Single.concat(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concat(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources, int prefetch)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence and prefetched by the specified amount.
static <@NonNull T> @NonNull Flowable<T>	Single.concatDelayError(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of SingleSources into a single sequence by subscribing to each SingleSource, one after the other, one at a time and delays any errors till the all inner SingleSources terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatDelayError(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatDelayError(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources, int prefetch)	Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values and runs a limited number of the inner sources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEager(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values and runs a limited number of those inner SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.concatEagerDelayError(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, running at most the specified number of those inner SingleSources at once and delaying errors until all the inner and the outer sequence terminate.
<@NonNull R> @NonNull Single<R>	Single.concatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
<@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
<@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, int prefetch)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.
<@NonNull R> @NonNull Maybe<R>	Maybe.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, int bufferSize)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.
<@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Flowable and all inner SingleSources terminate.
<@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Flowable and all inner SingleSources terminate.
<@NonNull R> @NonNull Flowable<R>	Flowable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Flowable and all inner SingleSources terminate.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the current Observable and all inner SingleSources terminate.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the current Observable and all inner SingleSources terminate.
<@NonNull R> @NonNull Observable<R>	Observable.concatMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize)	Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the current Observable and all inner SingleSources terminate.
static <@NonNull T> @NonNull Single<T>	Single.defer(@NonNull Supplier<? extends @NonNull SingleSource<? extends @NonNull T>> supplier)	Calls a Supplier for each individual SingleObserver to return the actual SingleSource to be subscribed to.
<@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
<@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super java.lang.Throwable,? extends SingleSource<? extends @NonNull R>> onErrorMapper)	Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.
<@NonNull U,@NonNull R> @NonNull Single<R>	Single.flatMap(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super @NonNull T,? super @NonNull U,? extends @NonNull R> combiner)	Returns a Single that emits the results of a specified function to the pair of values emitted by the current Single and a specified mapped SingleSource.
<@NonNull R> @NonNull Flowable<R>	Flowable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.
<@NonNull R> @NonNull Flowable<R>	Flowable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors, int maxConcurrency)	Maps each element of the upstream Flowable into SingleSources, subscribes to at most maxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.
<@NonNull R> @NonNull Maybe<R>	Maybe.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.
<@NonNull R> @NonNull Observable<R>	Observable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps each element of the current Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.
<@NonNull R> @NonNull Observable<R>	Observable.flatMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper, boolean delayErrors)	Maps each element of the current Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.
static <@NonNull T> @NonNull Single<T>	Single.merge(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source)	Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item emitted by the nested SingleSource, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.merge(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of SingleSource instances into one Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	Single.mergeDelayError(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Merges a sequence of SingleSource instances emitted by a Publisher into a Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
@NonNull Single<T>	Single.onErrorResumeNext(@NonNull Function<? super java.lang.Throwable,? extends SingleSource<? extends @NonNull T>> fallbackSupplier)	Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a function instead of signaling the error via onError.
<@NonNull R> @NonNull Flowable<R>	Flowable.switchMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if this Flowable or any of the active inner SingleSources fail.
<@NonNull R> @NonNull Observable<R>	Observable.switchMapSingle(@NonNull Function<? super @NonNull T,? extends SingleSource<? 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 a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.
<@NonNull R> @NonNull Flowable<R>	Flowable.switchMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? extends @NonNull R>> mapper)	Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from this Flowable or the inner SingleSources until all terminate.
<@NonNull R> @NonNull Observable<R>	Observable.switchMapSingleDelayError(@NonNull Function<? super @NonNull T,? extends SingleSource<? 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 a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.
static <@NonNull T> @NonNull Flowable<T>	Single.switchOnNext(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Switches between SingleSources emitted by the source Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	Single.switchOnNextDelayError(@NonNull org.reactivestreams.Publisher<? extends SingleSource<? extends @NonNull T>> sources)	Switches between SingleSources emitted by the source Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.
static <@NonNull T,@NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U,? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T,@NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U,? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup, boolean eager)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T,@NonNull R> @NonNull Single<R>	Single.zip(@NonNull java.lang.Iterable<? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super java.lang.Object[],? extends @NonNull R> zipper)	Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to the downstream.

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

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

Modifier and Type	Method	Description
@NonNull SingleSource<T>	HasUpstreamSingleSource.source()	Returns the upstream source of this Single.

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

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

Modifier and Type	Class	Description
class	FlowableCollectWithCollectorSingle<T,A,R>	Collect items into a container defined by a Stream Collector callback set.
class	ObservableCollectWithCollectorSingle<T,A,R>	Collect items into a container defined by a Stream Collector callback set.
class	SingleFromCompletionStage<T>	Wrap a CompletionStage and signal its outcome.

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

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

Modifier and Type	Class	Description
class	CompletableMaterialize<T>	Turn the signal types of a Completable source into a single Notification of equal kind.
class	CompletableToSingle<T>

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

Modifier and Type	Field	Description
(package private) SingleSource<T>	CompletableFromSingle.single

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

Constructor	Description
CompletableFromSingle(SingleSource<T> single)

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

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement SingleSource

Modifier and Type	Class	Description
class	FlowableAllSingle<T>
class	FlowableAnySingle<T>
class	FlowableCollectSingle<T,U>
class	FlowableCountSingle<T>
class	FlowableElementAtSingle<T>
class	FlowableLastSingle<T>	Consumes the source Publisher and emits its last item or the defaultItem if empty.
class	FlowableReduceSeedSingle<T,R>	Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.
class	FlowableReduceWithSingle<T,R>	Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.
class	FlowableSequenceEqualSingle<T>
class	FlowableSingleSingle<T>
class	FlowableToListSingle<T,U extends java.util.Collection<? super T>>

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

Modifier and Type	Field	Description
(package private) SingleSource<? extends T>	FlowableConcatWithSingle.ConcatWithSubscriber.other
(package private) SingleSource<? extends T>	FlowableConcatWithSingle.other
(package private) SingleSource<? extends T>	FlowableMergeWithSingle.other

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type SingleSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableFlatMapSingle.FlatMapSingleSubscriber.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableFlatMapSingle.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableFlatMapSinglePublisher.mapper

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

Constructor	Description
ConcatWithSubscriber(org.reactivestreams.Subscriber<? super T> actual, SingleSource<? extends T> other)
FlowableConcatWithSingle(Flowable<T> source, SingleSource<? extends T> other)
FlowableMergeWithSingle(Flowable<T> source, SingleSource<? extends T> other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.flowable with type arguments of type SingleSource

Constructor	Description
FlatMapSingleSubscriber(org.reactivestreams.Subscriber<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors, int maxConcurrency)
FlowableFlatMapSingle(Flowable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayError, int maxConcurrency)
FlowableFlatMapSinglePublisher(org.reactivestreams.Publisher<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayError, int maxConcurrency)

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

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

Modifier and Type	Class	Description
class	MaybeContains<T>	Signals true if the source signals a value that is object-equals with the provided value, false otherwise or for empty sources.
class	MaybeCount<T>	Signals 1L if the source signalled an item or 0L if the source is empty.
class	MaybeEqualSingle<T>	Compares two MaybeSources to see if they are both empty or emit the same value compared via a BiPredicate.
class	MaybeIsEmptySingle<T>	Signals true if the source Maybe signals onComplete, signals false if the source Maybe signals onSuccess.
class	MaybeMaterialize<T>	Turn the signal types of a Maybe source into a single Notification of equal kind.
class	MaybeSwitchIfEmptySingle<T>	Subscribes to the other source if the main source is empty.
class	MaybeToSingle<T>	Wraps a MaybeSource and exposes its onSuccess and onError signals and signals NoSuchElementException for onComplete if defaultValue is null.

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as SingleSource

Modifier and Type	Field	Description
(package private) SingleSource<? extends T>	MaybeSwitchIfEmptySingle.other
(package private) SingleSource<? extends T>	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.other
(package private) SingleSource<T>	MaybeFilterSingle.source
(package private) SingleSource<T>	MaybeFromSingle.source

Fields in io.reactivex.rxjava3.internal.operators.maybe with type parameters of type SingleSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends SingleSource<? extends R>>	MaybeFlatMapSingle.FlatMapMaybeObserver.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	MaybeFlatMapSingle.mapper

Methods in io.reactivex.rxjava3.internal.operators.maybe that return SingleSource

Modifier and Type	Method	Description
SingleSource<T>	MaybeFromSingle.source()

Constructors in io.reactivex.rxjava3.internal.operators.maybe with parameters of type SingleSource

Constructor	Description
MaybeFilterSingle(SingleSource<T> source, Predicate<? super T> predicate)
MaybeFromSingle(SingleSource<T> source)
MaybeSwitchIfEmptySingle(MaybeSource<T> source, SingleSource<? extends T> other)
SwitchIfEmptyMaybeObserver(SingleObserver<? super T> actual, SingleSource<? extends T> other)

Constructor parameters in io.reactivex.rxjava3.internal.operators.maybe with type arguments of type SingleSource

Constructor	Description
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> mapper)
MaybeFlatMapSingle(MaybeSource<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper)

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

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

Modifier and Type	Field	Description
(package private) SingleSource<T>	SingleFlatMapObservable.source

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

Modifier and Type	Field	Description
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableConcatMapSingle.ConcatMapSingleSubscriber.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableConcatMapSingle.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableConcatMapSinglePublisher.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableSwitchMapSingle.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableSwitchMapSingle.SwitchMapSingleSubscriber.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	FlowableSwitchMapSinglePublisher.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	ObservableConcatMapSingle.ConcatMapSingleMainObserver.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	ObservableConcatMapSingle.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	ObservableSwitchMapSingle.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	ObservableSwitchMapSingle.SwitchMapSingleMainObserver.mapper

Method parameters in io.reactivex.rxjava3.internal.operators.mixed with type arguments of type SingleSource

Modifier and Type	Method	Description
(package private) static <T,R> boolean	ScalarXMapZHelper.tryAsSingle(java.lang.Object source, Function<? super T,? extends SingleSource<? extends R>> mapper, Observer<? super R> observer)	Try subscribing to a SingleSource mapped from a scalar source (which implements Supplier).

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

Constructor	Description
SingleFlatMapObservable(SingleSource<T> source, Function<? super T,? extends ObservableSource<? extends R>> mapper)

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

Constructor	Description
ConcatMapSingleMainObserver(Observer<? super R> downstream, Function<? super T,? extends SingleSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
ConcatMapSingleSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T,? extends SingleSource<? extends R>> mapper, int prefetch, ErrorMode errorMode)
FlowableConcatMapSingle(Flowable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
FlowableConcatMapSinglePublisher(org.reactivestreams.Publisher<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
FlowableSwitchMapSingle(Flowable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)
FlowableSwitchMapSinglePublisher(org.reactivestreams.Publisher<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)
ObservableConcatMapSingle(ObservableSource<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, ErrorMode errorMode, int prefetch)
ObservableSwitchMapSingle(Observable<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)
SwitchMapSingleMainObserver(Observer<? super R> downstream, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)
SwitchMapSingleSubscriber(org.reactivestreams.Subscriber<? super R> downstream, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)

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

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

Modifier and Type	Class	Description
class	ObservableAllSingle<T>
class	ObservableAnySingle<T>
class	ObservableCollectSingle<T,U>
class	ObservableCountSingle<T>
class	ObservableElementAtSingle<T>
class	ObservableLastSingle<T>	Consumes the source ObservableSource and emits its last item, the defaultItem if empty or a NoSuchElementException if even the defaultItem is null.
class	ObservableReduceSeedSingle<T,R>	Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.
class	ObservableReduceWithSingle<T,R>	Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.
class	ObservableSequenceEqualSingle<T>
class	ObservableSingleSingle<T>
class	ObservableToListSingle<T,U extends java.util.Collection<? super T>>

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

Modifier and Type	Field	Description
(package private) SingleSource<? extends T>	ObservableConcatWithSingle.ConcatWithObserver.other
(package private) SingleSource<? extends T>	ObservableConcatWithSingle.other
(package private) SingleSource<? extends T>	ObservableMergeWithSingle.other

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

Modifier and Type	Field	Description
(package private) Function<? super T,? extends SingleSource<? extends R>>	ObservableFlatMapSingle.FlatMapSingleObserver.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	ObservableFlatMapSingle.mapper

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

Constructor	Description
ConcatWithObserver(Observer<? super T> actual, SingleSource<? extends T> other)
ObservableConcatWithSingle(Observable<T> source, SingleSource<? extends T> other)
ObservableMergeWithSingle(Observable<T> source, SingleSource<? extends T> other)

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

Constructor	Description
FlatMapSingleObserver(Observer<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayErrors)
ObservableFlatMapSingle(ObservableSource<T> source, Function<? super T,? extends SingleSource<? extends R>> mapper, boolean delayError)

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

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

Modifier and Type	Class	Description
class	SingleAmb<T>
class	SingleCache<T>
class	SingleContains<T>
class	SingleCreate<T>
class	SingleDefer<T>
class	SingleDelay<T>
class	SingleDelayWithCompletable<T>
class	SingleDelayWithObservable<T,U>
class	SingleDelayWithPublisher<T,U>
class	SingleDelayWithSingle<T,U>
class	SingleDetach<T>	Breaks the references between the upstream and downstream when the Maybe terminates.
class	SingleDoAfterSuccess<T>	Calls a consumer after pushing the current item to the downstream.
class	SingleDoAfterTerminate<T>	Calls an action after pushing the current item or an error to the downstream.
class	SingleDoFinally<T>	Execute an action after an onSuccess, onError or a dispose event.
class	SingleDoOnDispose<T>
class	SingleDoOnError<T>
class	SingleDoOnEvent<T>
class	SingleDoOnLifecycle<T>	Invokes callbacks upon onSubscribe from upstream and dispose from downstream.
class	SingleDoOnSubscribe<T>	Calls a callback when the upstream calls onSubscribe with a disposable.
class	SingleDoOnSuccess<T>
class	SingleDoOnTerminate<T>
class	SingleEquals<T>
class	SingleError<T>
class	SingleFlatMap<T,R>
class	SingleFlatMapBiSelector<T,U,R>	Maps a source item to another SingleSource then calls a BiFunction with the original item and the secondary item to generate the final result.
class	SingleFlatMapNotification<T,R>	Maps a value into a SingleSource and relays its signal.
class	SingleFromCallable<T>
class	SingleFromPublisher<T>
class	SingleFromSupplier<T>	Calls a supplier and emits its value or exception to the incoming SingleObserver.
class	SingleFromUnsafeSource<T>
class	SingleHide<T>
class	SingleJust<T>
class	SingleLift<T,R>
class	SingleMap<T,R>
class	SingleMaterialize<T>	Turn the signal types of a Single source into a single Notification of equal kind.
class	SingleNever
class	SingleObserveOn<T>
class	SingleOnErrorReturn<T>
class	SingleResumeNext<T>
class	SingleSubscribeOn<T>
class	SingleTakeUntil<T,U>	Signals the events of the source Single or signals a CancellationException if the other Publisher signalled first.
class	SingleTimeInterval<T>	Measures the time between subscription and the success item emission from the upstream and emits this as a Timed success value.
class	SingleTimeout<T>
class	SingleTimer	Signals a 0L after the specified delay.
class	SingleUnsubscribeOn<T>	Makes sure a dispose() call from downstream happens on the specified scheduler.
class	SingleUsing<T,U>
class	SingleZipArray<T,R>
class	SingleZipIterable<T,R>

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

Modifier and Type	Field	Description
(package private) SingleSource<? extends T>	SingleEquals.first
(package private) SingleSource<U>	SingleDelayWithSingle.other
(package private) SingleSource<? extends T>	SingleTimeout.other
(package private) SingleSource<? extends T>	SingleTimeout.TimeoutMainObserver.other
(package private) SingleSource<? extends T>	SingleEquals.second
(package private) SingleSource<? extends T>	SingleCache.source
(package private) SingleSource<T>	SingleContains.source
(package private) SingleSource<? extends T>	SingleDelay.source
(package private) SingleSource<T>	SingleDelayWithCompletable.OtherObserver.source
(package private) SingleSource<T>	SingleDelayWithCompletable.source
(package private) SingleSource<T>	SingleDelayWithObservable.OtherSubscriber.source
(package private) SingleSource<T>	SingleDelayWithObservable.source
(package private) SingleSource<T>	SingleDelayWithPublisher.OtherSubscriber.source
(package private) SingleSource<T>	SingleDelayWithPublisher.source
(package private) SingleSource<T>	SingleDelayWithSingle.OtherObserver.source
(package private) SingleSource<T>	SingleDelayWithSingle.source
(package private) SingleSource<T>	SingleDetach.source
(package private) SingleSource<T>	SingleDoAfterSuccess.source
(package private) SingleSource<T>	SingleDoAfterTerminate.source
(package private) SingleSource<T>	SingleDoFinally.source
(package private) SingleSource<T>	SingleDoOnDispose.source
(package private) SingleSource<T>	SingleDoOnError.source
(package private) SingleSource<T>	SingleDoOnEvent.source
(package private) SingleSource<T>	SingleDoOnSubscribe.source
(package private) SingleSource<T>	SingleDoOnSuccess.source
(package private) SingleSource<T>	SingleDoOnTerminate.source
(package private) SingleSource<? extends T>	SingleFlatMap.source
(package private) SingleSource<T>	SingleFlatMapBiSelector.source
(package private) SingleSource<T>	SingleFlatMapCompletable.source
(package private) SingleSource<T>	SingleFlatMapIterableFlowable.source
(package private) SingleSource<T>	SingleFlatMapIterableObservable.source
(package private) SingleSource<? extends T>	SingleFlatMapMaybe.source
(package private) SingleSource<T>	SingleFlatMapNotification.source
(package private) SingleSource<T>	SingleFlatMapPublisher.source
(package private) SingleSource<T>	SingleFromUnsafeSource.source
(package private) SingleSource<? extends T>	SingleHide.source
(package private) SingleSource<T>	SingleLift.source
(package private) SingleSource<? extends T>	SingleMap.source
(package private) SingleSource<T>	SingleObserveOn.source
(package private) SingleSource<? extends T>	SingleOnErrorReturn.source
(package private) SingleSource<? extends T>	SingleResumeNext.source
(package private) SingleSource<? extends T>	SingleSubscribeOn.source
(package private) SingleSource<? extends T>	SingleSubscribeOn.SubscribeOnObserver.source
(package private) SingleSource<T>	SingleTakeUntil.source
(package private) SingleSource<T>	SingleTimeInterval.source
(package private) SingleSource<T>	SingleTimeout.source
(package private) SingleSource<? extends T>	SingleToFlowable.source
(package private) SingleSource<? extends T>	SingleToObservable.source
(package private) SingleSource<T>	SingleUnsubscribeOn.source
private SingleSource<? extends T>[]	SingleAmb.sources
(package private) SingleSource<? extends T>[]	SingleZipArray.sources

Fields in io.reactivex.rxjava3.internal.operators.single with type parameters of type SingleSource

Modifier and Type	Field	Description
(package private) Function<? super T,? extends SingleSource<? extends R>>	SingleFlatMap.mapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	SingleFlatMap.SingleFlatMapCallback.mapper
(package private) Function<? super T,? extends SingleSource<? extends U>>	SingleFlatMapBiSelector.FlatMapBiMainObserver.mapper
(package private) Function<? super T,? extends SingleSource<? extends U>>	SingleFlatMapBiSelector.mapper
(package private) Function<? super java.lang.Throwable,? extends SingleSource<? extends T>>	SingleResumeNext.nextFunction
(package private) Function<? super java.lang.Throwable,? extends SingleSource<? extends T>>	SingleResumeNext.ResumeMainSingleObserver.nextFunction
(package private) Function<? super java.lang.Throwable,? extends SingleSource<? extends R>>	SingleFlatMapNotification.FlatMapSingleObserver.onErrorMapper
(package private) Function<? super java.lang.Throwable,? extends SingleSource<? extends R>>	SingleFlatMapNotification.onErrorMapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	SingleFlatMapNotification.FlatMapSingleObserver.onSuccessMapper
(package private) Function<? super T,? extends SingleSource<? extends R>>	SingleFlatMapNotification.onSuccessMapper
(package private) Function<? super U,? extends SingleSource<? extends T>>	SingleUsing.singleFunction
(package private) Supplier<? extends SingleSource<? extends T>>	SingleDefer.singleSupplier
private java.util.Iterator<? extends SingleSource<? extends T>>	SingleInternalHelper.ToFlowableIterator.sit
private java.lang.Iterable<? extends SingleSource<? extends T>>	SingleInternalHelper.ToFlowableIterable.sources
(package private) java.lang.Iterable<? extends SingleSource<? extends T>>	SingleZipIterable.sources
private java.lang.Iterable<? extends SingleSource<? extends T>>	SingleAmb.sourcesIterable

Methods in io.reactivex.rxjava3.internal.operators.single that return types with arguments of type SingleSource

Modifier and Type	Method	Description
static <T> Function<SingleSource<? extends T>,org.reactivestreams.Publisher<? extends T>>	SingleInternalHelper.toFlowable()

Methods in io.reactivex.rxjava3.internal.operators.single with parameters of type SingleSource

Modifier and Type	Method	Description
org.reactivestreams.Publisher	SingleInternalHelper.ToFlowable.apply(SingleSource v)

Method parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type SingleSource

Modifier and Type	Method	Description
static <T> java.lang.Iterable<? extends Flowable<T>>	SingleInternalHelper.iterableToFlowable(java.lang.Iterable<? extends SingleSource<? extends T>> sources)

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

Constructor	Description
OtherObserver(SingleObserver<? super T> actual, SingleSource<T> source)
OtherObserver(SingleObserver<? super T> actual, SingleSource<T> source)
OtherSubscriber(SingleObserver<? super T> actual, SingleSource<T> source)
OtherSubscriber(SingleObserver<? super T> actual, SingleSource<T> source)
SingleAmb(SingleSource<? extends T>[] sources, java.lang.Iterable<? extends SingleSource<? extends T>> sourcesIterable)
SingleCache(SingleSource<? extends T> source)
SingleContains(SingleSource<T> source, java.lang.Object value, BiPredicate<java.lang.Object,java.lang.Object> comparer)
SingleDelay(SingleSource<? extends T> source, long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
SingleDelayWithCompletable(SingleSource<T> source, CompletableSource other)
SingleDelayWithObservable(SingleSource<T> source, ObservableSource<U> other)
SingleDelayWithPublisher(SingleSource<T> source, org.reactivestreams.Publisher<U> other)
SingleDelayWithSingle(SingleSource<T> source, SingleSource<U> other)
SingleDetach(SingleSource<T> source)
SingleDoAfterSuccess(SingleSource<T> source, Consumer<? super T> onAfterSuccess)
SingleDoAfterTerminate(SingleSource<T> source, Action onAfterTerminate)
SingleDoFinally(SingleSource<T> source, Action onFinally)
SingleDoOnDispose(SingleSource<T> source, Action onDispose)
SingleDoOnError(SingleSource<T> source, Consumer<? super java.lang.Throwable> onError)
SingleDoOnEvent(SingleSource<T> source, BiConsumer<? super T,? super java.lang.Throwable> onEvent)
SingleDoOnSubscribe(SingleSource<T> source, Consumer<? super Disposable> onSubscribe)
SingleDoOnSuccess(SingleSource<T> source, Consumer<? super T> onSuccess)
SingleDoOnTerminate(SingleSource<T> source, Action onTerminate)
SingleEquals(SingleSource<? extends T> first, SingleSource<? extends T> second)
SingleFlatMap(SingleSource<? extends T> source, Function<? super T,? extends SingleSource<? extends R>> mapper)
SingleFlatMapBiSelector(SingleSource<T> source, Function<? super T,? extends SingleSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
SingleFlatMapCompletable(SingleSource<T> source, Function<? super T,? extends CompletableSource> mapper)
SingleFlatMapIterableFlowable(SingleSource<T> source, Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
SingleFlatMapIterableObservable(SingleSource<T> source, Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)
SingleFlatMapMaybe(SingleSource<? extends T> source, Function<? super T,? extends MaybeSource<? extends R>> mapper)
SingleFlatMapNotification(SingleSource<T> source, Function<? super T,? extends SingleSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends SingleSource<? extends R>> onErrorMapper)
SingleFlatMapPublisher(SingleSource<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
SingleFromUnsafeSource(SingleSource<T> source)
SingleHide(SingleSource<? extends T> source)
SingleLift(SingleSource<T> source, SingleOperator<? extends R,? super T> onLift)
SingleMap(SingleSource<? extends T> source, Function<? super T,? extends R> mapper)
SingleObserveOn(SingleSource<T> source, Scheduler scheduler)
SingleOnErrorReturn(SingleSource<? extends T> source, Function<? super java.lang.Throwable,? extends T> valueSupplier, T value)
SingleResumeNext(SingleSource<? extends T> source, Function<? super java.lang.Throwable,? extends SingleSource<? extends T>> nextFunction)
SingleSubscribeOn(SingleSource<? extends T> source, Scheduler scheduler)
SingleTakeUntil(SingleSource<T> source, org.reactivestreams.Publisher<U> other)
SingleTimeInterval(SingleSource<T> source, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean start)
SingleTimeout(SingleSource<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, SingleSource<? extends T> other)
SingleToFlowable(SingleSource<? extends T> source)
SingleToObservable(SingleSource<? extends T> source)
SingleUnsubscribeOn(SingleSource<T> source, Scheduler scheduler)
SingleZipArray(SingleSource<? extends T>[] sources, Function<? super java.lang.Object[],? extends R> zipper)
SubscribeOnObserver(SingleObserver<? super T> actual, SingleSource<? extends T> source)
TimeoutMainObserver(SingleObserver<? super T> actual, SingleSource<? extends T> other, long timeout, java.util.concurrent.TimeUnit unit)

Constructor parameters in io.reactivex.rxjava3.internal.operators.single with type arguments of type SingleSource

Constructor	Description
FlatMapBiMainObserver(SingleObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
FlatMapSingleObserver(SingleObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends SingleSource<? extends R>> onErrorMapper)
ResumeMainSingleObserver(SingleObserver<? super T> actual, Function<? super java.lang.Throwable,? extends SingleSource<? extends T>> nextFunction)
SingleAmb(SingleSource<? extends T>[] sources, java.lang.Iterable<? extends SingleSource<? extends T>> sourcesIterable)
SingleDefer(Supplier<? extends SingleSource<? extends T>> singleSupplier)
SingleFlatMap(SingleSource<? extends T> source, Function<? super T,? extends SingleSource<? extends R>> mapper)
SingleFlatMapBiSelector(SingleSource<T> source, Function<? super T,? extends SingleSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
SingleFlatMapCallback(SingleObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> mapper)
SingleFlatMapNotification(SingleSource<T> source, Function<? super T,? extends SingleSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends SingleSource<? extends R>> onErrorMapper)
SingleResumeNext(SingleSource<? extends T> source, Function<? super java.lang.Throwable,? extends SingleSource<? extends T>> nextFunction)
SingleUsing(Supplier<U> resourceSupplier, Function<? super U,? extends SingleSource<? extends T>> singleFunction, Consumer<? super U> disposer, boolean eager)
SingleZipIterable(java.lang.Iterable<? extends SingleSource<? extends T>> sources, Function<? super java.lang.Object[],? extends R> zipper)
ToFlowableIterable(java.lang.Iterable<? extends SingleSource<? extends T>> sources)
ToFlowableIterator(java.util.Iterator<? extends SingleSource<? extends T>> sit)

Uses of SingleSource in io.reactivex.rxjava3.subjects

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

Modifier and Type	Class	Description
class	SingleSubject<T>	Represents a hot Single-like source and consumer of events similar to Subjects.