io.reactivex.rxjava3.core

Class Single<T>

java.lang.Object

io.reactivex.rxjava3.core.Single<T>

Type Parameters:

T - the type of the item emitted by the Single

All Implemented Interfaces:

SingleSource<T>

Direct Known Subclasses:

SingleSubject

public abstract class Single<T>
extends Object
implements SingleSource<T>

The Single class implements the Reactive Pattern for a single value response.

Single behaves similarly to Observable except that it can only emit either a single successful value or an error (there is no onComplete notification as there is for an Observable).

The Single class implements the SingleSource base interface and the default consumer type it interacts with is the SingleObserver via the subscribe(SingleObserver) method.

The Single operates with the following sequential protocol:

     onSubscribe (onSuccess | onError)?
 

Note that onSuccess and onError are mutually exclusive events; unlike Observable, onSuccess is never followed by onError.

Like Observable, a running Single can be stopped through the Disposable instance provided to consumers through SingleObserver.onSubscribe(io.reactivex.rxjava3.disposables.Disposable).

Like an Observable, a Single is lazy, can be either "hot" or "cold", synchronous or asynchronous. Single instances returned by the methods of this class are cold and there is a standard hot implementation in the form of a subject: SingleSubject.

The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:

See Flowable or Observable for the implementation of the Reactive Pattern for a stream or vector of values.

For more information see the ReactiveX documentation.

Example:

 Disposable d = Single.just("Hello World")
    .delay(10, TimeUnit.SECONDS, Schedulers.io())
    .subscribeWith(new DisposableSingleObserver<String>() {
        @Override
        public void onStart() {
            System.out.println("Started");
        }

        @Override
        public void onSuccess(String value) {
            System.out.println("Success: " + value);
        }

        @Override
        public void onError(Throwable error) {
            error.printStackTrace();
        }
    });
 
 Thread.sleep(5000);
 
 d.dispose();
 

Note that by design, subscriptions via subscribe(SingleObserver) can't be disposed from the outside (hence the void return of the subscribe(SingleObserver) method) and it is the responsibility of the implementor of the SingleObserver to allow this to happen. RxJava supports such usage with the standard DisposableSingleObserver instance. For convenience, the subscribeWith(SingleObserver) method is provided as well to allow working with a SingleObserver (or subclass) instance to be applied with in a fluent manner (such as in the example above).

Since:

2.0

See Also:

DisposableSingleObserver

Constructor Summary

Constructors

Constructor and Description
Single()

Method Summary

Modifier and Type	Method and Description
static <T> @NonNull Single<T>	amb(@NonNull Iterable<? extends SingleSource<? extends T>> sources) Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
static <T> @NonNull Single<T>	ambArray(SingleSource<? extends T>... sources) Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
@NonNull Single<T>	ambWith(@NonNull SingleSource<? extends T> other) Signals the event of this or the other SingleSource whichever signals first.
T	blockingGet() Waits in a blocking fashion until the current Single signals a success value (which is returned) or an exception (which is propagated).
void	blockingSubscribe() Subscribes to the current Single and blocks the current thread until it terminates.
void	blockingSubscribe(@NonNull Consumer<? super T> onSuccess) Subscribes to the current Single and calls given onSuccess callback on the current thread when it completes normally.
void	blockingSubscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to the current Single and calls the appropriate callback on the current thread when it terminates.
void	blockingSubscribe(@NonNull SingleObserver<? super T> observer) Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread.
@NonNull Single<T>	cache() Stores the success value or exception from the current Single and replays it to late SingleObservers.
<U> @NonNull Single<U>	cast(@NonNull Class<? extends U> clazz) Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.
<R> @NonNull Single<R>	compose(@NonNull SingleTransformer<? super T,? extends R> transformer) Transform a Single by applying a particular SingleTransformer function to it.
static <T> @NonNull Flowable<T>	concat(@NonNull Iterable<? extends SingleSource<? extends T>> sources) Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.
static <T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends SingleSource<? extends T>> sources) Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an ObservableSource sequence.
static <T> @NonNull Flowable<T>	concat(@NonNull Publisher<? extends SingleSource<? extends T>> sources) Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.
static <T> @NonNull Flowable<T>	concat(@NonNull Publisher<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concat(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2) Returns a Flowable that emits the items emitted by two SingleSources, one after the other.
static <T> @NonNull Flowable<T>	concat(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2, @NonNull SingleSource<? extends T> source3) Returns a Flowable that emits the items emitted by three SingleSources, one after the other.
static <T> @NonNull Flowable<T>	concat(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2, @NonNull SingleSource<? extends T> source3, @NonNull SingleSource<? extends T> source4) Returns a Flowable that emits the items emitted by four SingleSources, one after the other.
static <T> @NonNull Flowable<T>	concatArray(SingleSource<? extends T>... sources) Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <T> @NonNull Flowable<T>	concatArrayDelayError(SingleSource<? extends T>... sources) Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <T> @NonNull Flowable<T>	concatArrayEager(SingleSource<? extends T>... sources) Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <T> @NonNull Flowable<T>	concatArrayEagerDelayError(SingleSource<? extends T>... sources) Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <T> @NonNull Flowable<T>	concatDelayError(@NonNull Iterable<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatDelayError(@NonNull Publisher<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatDelayError(@NonNull Publisher<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatEager(@NonNull Iterable<? extends SingleSource<? extends T>> sources) Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.
static <T> @NonNull Flowable<T>	concatEager(@NonNull Iterable<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatEager(@NonNull Publisher<? extends SingleSource<? extends T>> sources) Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
static <T> @NonNull Flowable<T>	concatEager(@NonNull Publisher<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Iterable<? extends SingleSource<? extends T>> sources) Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Iterable<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Publisher<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.
<R> @NonNull Single<R>	concatMap(@NonNull Function<? super T,? extends SingleSource<? extends 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 Completable	concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper) Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.
<R> @NonNull Maybe<R>	concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.
@NonNull Flowable<T>	concatWith(@NonNull SingleSource<? extends T> other) Returns a Flowable that emits the item emitted by the current Single, then the item emitted by the specified SingleSource.
@NonNull Single<Boolean>	contains(@NonNull Object item) Signals true if the current Single signals a success value that is Object.equals(Object) with the value provided.
@NonNull Single<Boolean>	contains(@NonNull Object item, @NonNull BiPredicate<Object,Object> comparer) Signals true if the current Single signals a success value that is equal with the value provided by calling a BiPredicate.
static <T> @NonNull Single<T>	create(@NonNull SingleOnSubscribe<T> source) Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
static <T> @NonNull Single<T>	defer(@NonNull Supplier<? extends SingleSource<? extends T>> supplier) Calls a Supplier for each individual SingleObserver to return the actual SingleSource to be subscribed to.
@NonNull Single<T>	delay(long time, @NonNull TimeUnit unit) Delays the emission of the success signal from the current Single by the specified amount.
@NonNull Single<T>	delay(long time, @NonNull TimeUnit unit, boolean delayError) Delays the emission of the success or error signal from the current Single by the specified amount.
@NonNull Single<T>	delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Delays the emission of the success signal from the current Single by the specified amount.
@NonNull Single<T>	delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError) Delays the emission of the success or error signal from the current Single by the specified amount.
@NonNull Single<T>	delaySubscription(@NonNull CompletableSource subscriptionIndicator) Delays the actual subscription to the current Single until the given other CompletableSource completes.
@NonNull Single<T>	delaySubscription(long time, @NonNull TimeUnit unit) Delays the actual subscription to the current Single until the given time delay elapsed.
@NonNull Single<T>	delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Delays the actual subscription to the current Single until the given time delay elapsed.
<U> @NonNull Single<T>	delaySubscription(@NonNull ObservableSource<U> subscriptionIndicator) Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
<U> @NonNull Single<T>	delaySubscription(@NonNull Publisher<U> subscriptionIndicator) Delays the actual subscription to the current Single until the given other Publisher signals its first value or completes.
<U> @NonNull Single<T>	delaySubscription(@NonNull SingleSource<U> subscriptionIndicator) Delays the actual subscription to the current Single until the given other SingleSource signals success.
<R> @NonNull Maybe<R>	dematerialize(@NonNull Function<? super T,Notification<R>> selector) Maps the Notification success value of the current Single back into normal onSuccess, onError or onComplete signals as a Maybe source.
@NonNull Single<T>	doAfterSuccess(@NonNull Consumer<? super T> onAfterSuccess) Calls the specified consumer with the success item after this item has been emitted to the downstream.
@NonNull Single<T>	doAfterTerminate(@NonNull Action onAfterTerminate) Registers an Action to be called after this Single invokes either onSuccess or onError.
@NonNull Single<T>	doFinally(@NonNull Action onFinally) Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.
@NonNull Single<T>	doOnDispose(@NonNull Action onDispose) Calls the shared Action if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.
@NonNull Single<T>	doOnError(@NonNull Consumer<? super Throwable> onError) Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.
@NonNull Single<T>	doOnEvent(@NonNull BiConsumer<? super T,? super Throwable> onEvent) Calls the shared consumer with the error sent via onError or the value via onSuccess for each SingleObserver that subscribes to the current Single.
@NonNull Single<T>	doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose) Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Single<T>	doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe) Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.
@NonNull Single<T>	doOnSuccess(@NonNull Consumer<? super T> onSuccess) Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.
@NonNull Single<T>	doOnTerminate(@NonNull Action onTerminate) Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.
static <T> @NonNull Single<T>	error(@NonNull Supplier<? extends Throwable> supplier) Signals a Throwable returned by the callback function for each individual SingleObserver.
static <T> @NonNull Single<T>	error(@NonNull Throwable throwable) Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.
@NonNull Maybe<T>	filter(@NonNull Predicate<? super T> predicate) Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.
<R> @NonNull Single<R>	flatMap(@NonNull Function<? super T,? extends SingleSource<? extends 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.
<R> @NonNull Single<R>	flatMap(@NonNull Function<? super T,? extends SingleSource<? extends R>> onSuccessMapper, @NonNull Function<? super Throwable,? extends SingleSource<? extends R>> onErrorMapper) Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.
<U,R> @NonNull Single<R>	flatMap(@NonNull Function<? super T,? extends SingleSource<? extends U>> mapper, @NonNull BiFunction<? super T,? super U,? extends 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 Completable	flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper) Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.
<R> @NonNull Maybe<R>	flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper) Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.
<R> @NonNull Observable<R>	flatMapObservable(@NonNull Function<? super T,? extends ObservableSource<? extends 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.
<R> @NonNull Flowable<R>	flatMapPublisher(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper) Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Single, where that function returns a Publisher.
<U> @NonNull Flowable<U>	flattenAsFlowable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper) Maps the success value of the current Single into an Iterable and emits its items as a Flowable sequence.
<U> @NonNull Observable<U>	flattenAsObservable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper) Maps the success value of the current Single into an Iterable and emits its items as an Observable sequence.
<R> @NonNull Flowable<R>	flattenStreamAsFlowable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper) Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
<R> @NonNull Observable<R>	flattenStreamAsObservable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper) Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.
static <T> @NonNull Single<T>	fromCallable(@NonNull Callable<? extends T> callable) Returns a Single that invokes the given Callable for each incoming SingleObserver and emits its value or exception to them.
static <T> @NonNull Single<T>	fromCompletionStage(@NonNull CompletionStage<T> stage) Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <T> @NonNull Single<T>	fromFuture(@NonNull Future<? extends T> future) Converts a Future into a Single and awaits its outcome in a blocking fashion.
static <T> @NonNull Single<T>	fromFuture(@NonNull Future<? extends T> future, long timeout, @NonNull TimeUnit unit) Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.
static <T> @NonNull Single<T>	fromMaybe(@NonNull MaybeSource<T> maybe) Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or forwards the onError signal.
static <T> @NonNull Single<T>	fromMaybe(@NonNull MaybeSource<T> maybe, T defaultItem) Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, emits the defaultItem for an onComplete signal or forwards the onError signal.
static <T> @NonNull Single<T>	fromObservable(@NonNull ObservableSource<? extends T> observable) Wraps a specific ObservableSource into a Single and signals its single element or error.
static <T> @NonNull Single<T>	fromPublisher(@NonNull Publisher<? extends T> publisher) Wraps a specific Publisher into a Single and signals its single element or error.
static <T> @NonNull Single<T>	fromSupplier(@NonNull Supplier<? extends T> supplier) Returns a Single that invokes passed supplier and emits its result for each individual SingleObserver that subscribes.
@NonNull Single<T>	hide() Hides the identity of the current Single, including the Disposable that is sent to the downstream via onSubscribe().
@NonNull Completable	ignoreElement() Returns a Completable that ignores the success value of this Single and signals onComplete instead.
static <T> @NonNull Single<T>	just(T item) Returns a Single that emits a specified item.
<R> @NonNull Single<R>	lift(@NonNull SingleOperator<? extends R,? super T> lift) This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Single which, when subscribed to, invokes the apply(SingleObserver) method of the provided SingleOperator for each individual downstream Single and allows the insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase and providing a new SingleObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
<R> @NonNull Single<R>	map(@NonNull Function<? super T,? extends R> mapper) Returns a Single that applies a specified function to the item emitted by the current Single and emits the result of this function application.
<R> @NonNull Maybe<R>	mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper) Maps the upstream success value into an Optional and emits the contained item if not empty as a Maybe.
@NonNull Single<Notification<T>>	materialize() Maps the signal types of this Single into a Notification of the same kind and emits it as a single success value to downstream.
static <T> @NonNull Flowable<T>	merge(@NonNull Iterable<? extends SingleSource<? extends T>> sources) Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <T> @NonNull Flowable<T>	merge(@NonNull Publisher<? extends SingleSource<? extends T>> sources) Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, running all SingleSources at once.
static <T> @NonNull Single<T>	merge(@NonNull SingleSource<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	merge(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2) Flattens two SingleSources into one Flowable sequence, without any transformation.
static <T> @NonNull Flowable<T>	merge(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2, @NonNull SingleSource<? extends T> source3) Flattens three SingleSources into one Flowable sequence, without any transformation.
static <T> @NonNull Flowable<T>	merge(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2, @NonNull SingleSource<? extends T> source3, @NonNull SingleSource<? extends T> source4) Flattens four SingleSources into one Flowable sequence, without any transformation.
static <T> @NonNull Flowable<T>	mergeArray(SingleSource<? extends T>... sources) Merges an array of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <T> @NonNull Flowable<T>	mergeArrayDelayError(SingleSource<? extends 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 <T> @NonNull Flowable<T>	mergeDelayError(@NonNull Iterable<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	mergeDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.
static <T> @NonNull Flowable<T>	mergeDelayError(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2) Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <T> @NonNull Flowable<T>	mergeDelayError(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2, @NonNull SingleSource<? extends T> source3) Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <T> @NonNull Flowable<T>	mergeDelayError(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2, @NonNull SingleSource<? extends T> source3, @NonNull SingleSource<? extends T> source4) Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
@NonNull Flowable<T>	mergeWith(@NonNull SingleSource<? extends T> other) Flattens this Single and another SingleSource into one Flowable, without any transformation.
static <T> @NonNull Single<T>	never() Returns a singleton instance of a never-signaling Single (only calls onSubscribe).
@NonNull Single<T>	observeOn(@NonNull Scheduler scheduler) Signals the success item or the terminal signals of the current Single on the specified Scheduler, asynchronously.
<U> @NonNull Maybe<U>	ofType(@NonNull Class<U> clazz) Filters the items emitted by the current Single, only emitting its success value if that is an instance of the supplied Class.
@NonNull Maybe<T>	onErrorComplete() Returns a Maybe instance that if the current Single emits an error, it will emit an onComplete and swallow the throwable.
@NonNull Maybe<T>	onErrorComplete(@NonNull Predicate<? super Throwable> predicate) Returns a Maybe instance that if this Single emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
@NonNull Single<T>	onErrorResumeNext(@NonNull Function<? super Throwable,? extends SingleSource<? extends 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 Single<T>	onErrorResumeWith(@NonNull SingleSource<? extends T> fallback) Resumes the flow with the given SingleSource when the current Single fails instead of signaling the error via onError.
@NonNull Single<T>	onErrorReturn(@NonNull Function<Throwable,? extends T> itemSupplier) Ends the flow with a success item returned by a function for the Throwable error signaled by the current Single instead of signaling the error via onError.
@NonNull Single<T>	onErrorReturnItem(T item) Signals the specified value as success in case the current Single signals an error.
@NonNull Single<T>	onTerminateDetach() Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().
@NonNull Flowable<T>	repeat() Repeatedly re-subscribes to the current Single and emits each success value as a Flowable sequence.
@NonNull Flowable<T>	repeat(long times) Re-subscribes to the current Single at most the given number of times and emits each success value as a Flowable sequence.
@NonNull Flowable<T>	repeatUntil(@NonNull BooleanSupplier stop) Re-subscribes to the current Single until the given BooleanSupplier returns true and emits the success items as a Flowable sequence.
@NonNull Flowable<T>	repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler) Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.
@NonNull Single<T>	retry() Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
@NonNull Single<T>	retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate) Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
@NonNull Single<T>	retry(long times) Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.
@NonNull Single<T>	retry(long times, @NonNull Predicate<? super Throwable> predicate) Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first if it fails with an onError.
@NonNull Single<T>	retry(@NonNull Predicate<? super Throwable> predicate) Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.
@NonNull Single<T>	retryUntil(@NonNull BooleanSupplier stop) Retries until the given stop function returns true.
@NonNull Single<T>	retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler) Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.
void	safeSubscribe(@NonNull SingleObserver<? super T> observer) Wraps the given SingleObserver, catches any RuntimeExceptions thrown by its SingleObserver.onSubscribe(Disposable), SingleObserver.onSuccess(Object) or SingleObserver.onError(Throwable) methods* and routes those to the global error handler via RxJavaPlugins.onError(Throwable).
static <T> @NonNull Single<Boolean>	sequenceEqual(@NonNull SingleSource<? extends T> source1, @NonNull SingleSource<? extends T> source2) Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).
@NonNull Flowable<T>	startWith(@NonNull CompletableSource other) Returns a Flowable which first runs the other CompletableSource then the current Single if the other completed normally.
@NonNull Flowable<T>	startWith(@NonNull MaybeSource<T> other) Returns a Flowable which first runs the other MaybeSource then the current Single if the other succeeded or completed normally.
@NonNull Observable<T>	startWith(@NonNull ObservableSource<T> other) Returns an Observable which first delivers the events of the other ObservableSource then runs the current Single.
@NonNull Flowable<T>	startWith(@NonNull Publisher<T> other) Returns a Flowable which first delivers the events of the other Publisher then runs the current Single.
@NonNull Flowable<T>	startWith(@NonNull SingleSource<T> other) Returns a Flowable which first runs the other SingleSource then the current Single if the other succeeded normally.
@NonNull Disposable	subscribe() Subscribes to a Single but ignore its emission or notification.
@NonNull Disposable	subscribe(@NonNull BiConsumer<? super T,? super Throwable> onCallback) Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.
@NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess) Subscribes to a Single and provides a callback to handle the item it emits.
@NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError) Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.
@NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull DisposableContainer container) Wraps the given onXXX callbacks into a Disposable SingleObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the SingleObserver is removed from the given container.
void	subscribe(@NonNull SingleObserver<? super T> observer) Subscribes the given SingleObserver to this SingleSource instance.
protected abstract void	subscribeActual(@NonNull SingleObserver<? super T> observer) Implement this method in subclasses to handle the incoming SingleObservers.
@NonNull Single<T>	subscribeOn(@NonNull Scheduler scheduler) Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.
<E extends SingleObserver<? super T>> E	subscribeWith(E observer) Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.
static <T> @NonNull Flowable<T>	switchOnNext(@NonNull Publisher<? extends SingleSource<? extends 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 <T> @NonNull Flowable<T>	switchOnNextDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.
@NonNull Single<T>	takeUntil(@NonNull CompletableSource other) Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.
<E> @NonNull Single<T>	takeUntil(@NonNull Publisher<E> other) Returns a Single that emits the item emitted by the current Single until a Publisher emits an item or completes.
<E> @NonNull Single<T>	takeUntil(@NonNull SingleSource<? extends E> other) Returns a Single that emits the item emitted by the current Single until a second Single emits an item.
@NonNull TestObserver<T>	test() Creates a TestObserver and subscribes it to this Single.
@NonNull TestObserver<T>	test(boolean dispose) Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
@NonNull Single<Timed<T>>	timeInterval() Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
@NonNull Single<Timed<T>>	timeInterval(@NonNull Scheduler scheduler) Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
@NonNull Single<Timed<T>>	timeInterval(@NonNull TimeUnit unit) Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
@NonNull Single<Timed<T>>	timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
@NonNull Single<T>	timeout(long timeout, @NonNull TimeUnit unit) Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
@NonNull Single<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
@NonNull Single<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends 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>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull SingleSource<? extends 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.
static @NonNull Single<Long>	timer(long delay, @NonNull TimeUnit unit) Signals success with 0L value after the given delay when a SingleObserver subscribes.
static @NonNull Single<Long>	timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler) Signals success with 0L value on the specified Scheduler after the given delay when a SingleObserver subscribes.
@NonNull Single<Timed<T>>	timestamp() Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.
@NonNull Single<Timed<T>>	timestamp(@NonNull Scheduler scheduler) Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
@NonNull Single<Timed<T>>	timestamp(@NonNull TimeUnit unit) Combines the success value from the current Single with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.
@NonNull Single<Timed<T>>	timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler) Combines the success value from the current Single with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
<R> R	to(@NonNull SingleConverter<T,? extends R> converter) Calls the specified converter function during assembly time and returns its resulting value.
@NonNull CompletionStage<T>	toCompletionStage() Signals the upstream success item (or error) via a CompletionStage.
@NonNull Flowable<T>	toFlowable() Converts this Single into a Flowable.
@NonNull Future<T>	toFuture() Returns a Future representing the single value emitted by this Single.
@NonNull Maybe<T>	toMaybe() Converts this Single into a Maybe.
@NonNull Observable<T>	toObservable() Converts this Single into an Observable.
static <T> @NonNull Single<T>	unsafeCreate(@NonNull SingleSource<T> onSubscribe) Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
@NonNull Single<T>	unsubscribeOn(@NonNull Scheduler scheduler) Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified Scheduler.
static <T,U> @NonNull Single<T>	using(@NonNull Supplier<U> resourceSupplier, @NonNull Function<? super U,? extends SingleSource<? extends T>> sourceSupplier, @NonNull Consumer<? super U> resourceCleanup) Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <T,U> @NonNull Single<T>	using(@NonNull Supplier<U> resourceSupplier, @NonNull Function<? super U,? extends SingleSource<? extends T>> sourceSupplier, @NonNull Consumer<? super 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 <T> @NonNull Single<T>	wrap(@NonNull SingleSource<T> source) Wraps a SingleSource instance into a new Single instance if not already a Single instance.
static <T,R> @NonNull Single<R>	zip(@NonNull Iterable<? extends SingleSource<? extends T>> sources, @NonNull Function<? super Object[],? extends 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.
static <T1,T2,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull BiFunction<? super T1,? super T2,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other SingleSources.
static <T1,T2,T3,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other SingleSources.
static <T1,T2,T3,T4,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull SingleSource<? extends T4> source4, @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other SingleSources.
static <T1,T2,T3,T4,T5,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull SingleSource<? extends T4> source4, @NonNull SingleSource<? extends T5> source5, @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other SingleSources.
static <T1,T2,T3,T4,T5,T6,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull SingleSource<? extends T4> source4, @NonNull SingleSource<? extends T5> source5, @NonNull SingleSource<? extends T6> source6, @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other SingleSources.
static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull SingleSource<? extends T4> source4, @NonNull SingleSource<? extends T5> source5, @NonNull SingleSource<? extends T6> source6, @NonNull SingleSource<? extends T7> source7, @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other SingleSources.
static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull SingleSource<? extends T4> source4, @NonNull SingleSource<? extends T5> source5, @NonNull SingleSource<? extends T6> source6, @NonNull SingleSource<? extends T7> source7, @NonNull SingleSource<? extends T8> source8, @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other SingleSources.
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends T1> source1, @NonNull SingleSource<? extends T2> source2, @NonNull SingleSource<? extends T3> source3, @NonNull SingleSource<? extends T4> source4, @NonNull SingleSource<? extends T5> source5, @NonNull SingleSource<? extends T6> source6, @NonNull SingleSource<? extends T7> source7, @NonNull SingleSource<? extends T8> source8, @NonNull SingleSource<? extends T9> source9, @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper) Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other SingleSources.
static <T,R> @NonNull Single<R>	zipArray(@NonNull Function<? super Object[],? extends R> zipper, SingleSource<? extends 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.
<U,R> @NonNull Single<R>	zipWith(@NonNull SingleSource<U> other, @NonNull BiFunction<? super T,? super U,? extends 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.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Single

public Single()

Method Detail

amb

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> amb(@NonNull Iterable<? extends SingleSource<? extends T>> sources)

Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).

Scheduler:

amb does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the Iterable sequence of sources. A subscription to each source will occur in the same order as in this Iterable.

Returns:

the new Single instance

Throws:

NullPointerException - if sources is null

Since:

2.0

ambArray

@CheckReturnValue
 @SchedulerSupport(value="none")
 @SafeVarargs
 @NonNull
public static <T> @NonNull Single<T> ambArray(@NonNull SingleSource<? extends T>... sources)

Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).

Scheduler:

ambArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the array of sources. A subscription to each source will occur in the same order as in this array.

Returns:

the new Single instance

Throws:

NullPointerException - if sources is null

Since:

2.0

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> @NonNull Flowable<T> concat(@NonNull Iterable<? extends SingleSource<? extends T>> sources)

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the Iterable sequence of SingleSource instances

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

concat

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Observable<T> concat(@NonNull ObservableSource<? extends SingleSource<? extends T>> sources)

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an ObservableSource sequence.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the ObservableSource of SingleSource instances

Returns:

the new Observable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concat(@NonNull Publisher<? extends SingleSource<? extends T>> sources)

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer and the sources Publisher is expected to honor it as well.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the Publisher of SingleSource instances

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concat(@NonNull Publisher<? extends SingleSource<? extends 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.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer and the sources Publisher is expected to honor it as well.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the Publisher of SingleSource instances

prefetch - the number of SingleSources to prefetch from the Publisher

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if prefetch is non-positive

Since:

2.0

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concat(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2)

Returns a Flowable that emits the items emitted by two SingleSources, one after the other.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be concatenated

source2 - a SingleSource to be concatenated

Returns:

the new Flowable instance

Throws:

NullPointerException - if source1 or source2 is null

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concat(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2,
        @NonNull SingleSource<? extends T> source3)

Returns a Flowable that emits the items emitted by three SingleSources, one after the other.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be concatenated

source2 - a SingleSource to be concatenated

source3 - a SingleSource to be concatenated

Returns:

the new Flowable instance

Throws:

NullPointerException - if source1, source2 or source3 is null

See Also:

ReactiveX operators documentation: Concat

concat

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concat(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2,
        @NonNull SingleSource<? extends T> source3,
        @NonNull SingleSource<? extends T> source4)

Returns a Flowable that emits the items emitted by four SingleSources, one after the other.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concat does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be concatenated

source2 - a SingleSource to be concatenated

source3 - a SingleSource to be concatenated

source4 - a SingleSource to be concatenated

Returns:

the new Flowable instance

Throws:

NullPointerException - if source1, source2, source3 or source4 is null

See Also:

ReactiveX operators documentation: Concat

concatArray

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T> @NonNull Flowable<T> concatArray(@NonNull SingleSource<? extends T>... sources)

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concatArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the array of SingleSource instances

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

concatArrayDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T> @NonNull Flowable<T> concatArrayDelayError(@NonNull SingleSource<? extends T>... sources)

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concatArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - the array of SingleSource instances

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatArrayEager

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T> @NonNull Flowable<T> concatArrayEager(@NonNull SingleSource<? extends T>... sources)

Concatenates a sequence of SingleSource eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the value emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of SingleSources that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

concatArrayEagerDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T> @NonNull Flowable<T> concatArrayEagerDelayError(@NonNull SingleSource<? extends T>... sources)

Concatenates a sequence of SingleSource eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the value emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of SingleSources that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Iterable<? extends SingleSource<? extends 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.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Iterable sequence of SingleSources

Returns:

the new Flowable with the concatenating behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.

Backpressure:

concatDelayError fully supports backpressure.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Publisher sequence of SingleSources

Returns:

the new Flowable with the concatenating behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Flowable<T> concatDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.

Backpressure:

concatDelayError fully supports backpressure.

Scheduler:

concatDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the Publisher sequence of SingleSources

prefetch - The number of upstream items to prefetch so that fresh items are ready to be mapped when a previous SingleSource terminates. The operator replenishes after half of the prefetch amount has been consumed and turned into SingleSources.

Returns:

the new Flowable with the concatenating behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if prefetch is non-positive

Since:

3.0.0

concatEager

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends SingleSource<? extends T>> sources)

Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an Iterable sequence of SingleSource that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

concatEager

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEager(@NonNull Iterable<? extends SingleSource<? extends 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.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an Iterable sequence of SingleSource that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner SingleSources; Integer.MAX_VALUE is interpreted as all inner SingleSources can be active at the same time

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

3.0.0

concatEager

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends SingleSource<? extends T>> sources)

Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source SingleSources as they are observed. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of SingleSources that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

concatEager

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEager(@NonNull Publisher<? extends SingleSource<? extends 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.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source SingleSources as they are observed. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of SingleSources that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner SingleSources; Integer.MAX_VALUE is interpreted as all inner SingleSources can be active at the same time

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

3.0.0

concatEagerDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends SingleSource<? extends T>> sources)

Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an Iterable sequence of SingleSource that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatEagerDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Iterable<? extends SingleSource<? extends 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.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source SingleSources. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - an Iterable sequence of SingleSource that need to be eagerly concatenated

maxConcurrency - the maximum number of concurrently running inner SingleSources; Integer.MAX_VALUE is interpreted as all inner SingleSources can be active at the same time

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

3.0.0

concatEagerDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source SingleSources as they are observed. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of SingleSources that need to be eagerly concatenated

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

Since:

3.0.0

concatEagerDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> concatEagerDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.

Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source SingleSources as they are observed. The operator buffers the values emitted by these SingleSources and then drains them in order, each one after the previous one succeeds.

Backpressure:

Backpressure is honored towards the downstream and the outer Publisher is expected to support backpressure. Violating this assumption, the operator will signal MissingBackpressureException.

Scheduler:

This method does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

sources - a sequence of SingleSources that need to be eagerly concatenated

maxConcurrency - the number of inner SingleSources to run at once

Returns:

the new Flowable instance with the specified concatenation behavior

Throws:

NullPointerException - if sources is null

IllegalArgumentException - if maxConcurrency is non-positive

Since:

3.0.0

create

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> create(@NonNull SingleOnSubscribe<T> source)

Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.

Example:

 Single.<Event>create(emitter -> {
     Callback listener = new Callback() {
         @Override
         public void onEvent(Event e) {
             emitter.onSuccess(e);
         }

         @Override
         public void onFailure(Exception e) {
             emitter.onError(e);
         }
     };

     AutoCloseable c = api.someMethod(listener);

     emitter.setCancellable(c::close);

 });
 

Whenever a SingleObserver subscribes to the returned Single, the provided SingleOnSubscribe callback is invoked with a fresh instance of a SingleEmitter that will interact only with that specific SingleObserver. If this SingleObserver disposes the flow (making SingleEmitter.isDisposed() return true), other observers subscribed to the same returned Single are not affected.

Scheduler:

create does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

source - the emitter that is called when a SingleObserver subscribes to the returned Single

Returns:

the new Single instance

Throws:

NullPointerException - if source is null

See Also:

SingleOnSubscribe, Cancellable

defer

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> defer(@NonNull Supplier<? extends SingleSource<? extends T>> supplier)

Calls a Supplier for each individual SingleObserver to return the actual SingleSource to be subscribed to.

Scheduler:

defer does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

supplier - the Supplier that is called for each individual SingleObserver and returns a SingleSource instance to subscribe to

Returns:

the new Single instance

Throws:

NullPointerException - if supplier is null

error

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> error(@NonNull Supplier<? extends Throwable> supplier)

Signals a Throwable returned by the callback function for each individual SingleObserver.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

supplier - the Supplier that is called for each individual SingleObserver and returns a Throwable instance to be emitted.

Returns:

the new Single instance

Throws:

NullPointerException - if supplier is null

error

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> error(@NonNull Throwable throwable)

Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.

Scheduler:

error does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the item (ostensibly) emitted by the Single

Parameters:

throwable - the particular Throwable to pass to onError

Returns:

the new Single that invokes the subscriber's onError method when the subscriber subscribes to it

Throws:

NullPointerException - if throwable is null

See Also:

ReactiveX operators documentation: Throw

fromCallable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> fromCallable(@NonNull Callable<? extends T> callable)

Returns a Single that invokes the given Callable for each incoming SingleObserver and emits its value or exception to them.

Allows you to defer execution of passed function until SingleObserver subscribes to the Single. It makes passed function "lazy". Result of the function invocation will be emitted by the Single.

Scheduler:

fromCallable does not operate by default on a particular Scheduler.

Error handling:

If the Callable throws an exception, the respective Throwable is delivered to the downstream via SingleObserver.onError(Throwable), except when the downstream has disposed this Single source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the type of the item emitted by the Single.

Parameters:

callable - function which execution should be deferred, it will be invoked when SingleObserver will subscribe to the Single.

Returns:

the new Single whose SingleObservers' subscriptions trigger an invocation of the given function.

Throws:

NullPointerException - if callable is null

See Also:

defer(Supplier), fromSupplier(Supplier)

fromFuture

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<T> fromFuture(@NonNull Future<? extends T> future)

Converts a Future into a Single and awaits its outcome in a blocking fashion.

The operator calls Future.get(), which is a blocking method, on the subscription thread. It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a background thread, and if the Scheduler supports it, interrupt the wait when the flow is disposed.

A non-null value is then emitted via onSuccess or any exception is emitted via onError. If the Future completes with null, a NullPointerException is signaled.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Single

Parameters:

future - the source Future

Returns:

the new Single that emits the item from the source Future

Throws:

NullPointerException - if future is null

See Also:

ReactiveX operators documentation: From, fromFuture(Future, long, TimeUnit), fromCompletionStage(CompletionStage)

fromFuture

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<T> fromFuture(@NonNull Future<? extends T> future,
        long timeout,
        @NonNull TimeUnit unit)

Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.

The operator calls Future.get(long, TimeUnit), which is a blocking method, on the subscription thread. It is recommended applying subscribeOn(Scheduler) to move this blocking wait to a background thread, and if the Scheduler supports it, interrupt the wait when the flow is disposed.

A non-null value is then emitted via onSuccess or any exception is emitted via onError. If the Future completes with null, a NullPointerException is signaled.

Scheduler:

fromFuture does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of object that the Future returns, and also the type of item to be emitted by the resulting Single

Parameters:

future - the source Future

timeout - the maximum time to wait before calling get

unit - the TimeUnit of the timeout argument

Returns:

the new Single that emits the item from the source Future

Throws:

NullPointerException - if future or unit is null

See Also:

ReactiveX operators documentation: From

fromMaybe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> fromMaybe(@NonNull MaybeSource<T> maybe)

Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or forwards the onError signal.

Scheduler:

fromMaybe does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the MaybeSource element

Parameters:

maybe - the MaybeSource instance to subscribe to, not null

Returns:

the new Single instance

Throws:

NullPointerException - if maybe is null

Since:

3.0.0

fromMaybe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> fromMaybe(@NonNull MaybeSource<T> maybe,
        @NonNull T defaultItem)

Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, emits the defaultItem for an onComplete signal or forwards the onError signal.

Scheduler:

fromMaybe does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the MaybeSource element

Parameters:

maybe - the MaybeSource instance to subscribe to, not null

defaultItem - the item to signal if the current MaybeSource is empty

Returns:

the new Single instance

Throws:

NullPointerException - if maybe or defaultItem is null

Since:

3.0.0

fromPublisher

@BackpressureSupport(value=UNBOUNDED_IN)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> fromPublisher(@NonNull Publisher<? extends T> publisher)

Wraps a specific Publisher into a Single and signals its single element or error.

If the source Publisher is empty, a NoSuchElementException is signaled. If the source has more than one element, an IndexOutOfBoundsException is signaled.

The Publisher must follow the Reactive Streams specification. Violating the specification may result in undefined behavior.

If possible, use create(SingleOnSubscribe) to create a source-like Single instead.

Note that even though Publisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.

Backpressure:

The publisher is consumed in an unbounded fashion but will be cancelled if it produced more than one item.

Scheduler:

fromPublisher does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

publisher - the source Publisher instance, not null

Returns:

the new Single instance

Throws:

NullPointerException - if publisher is null

See Also:

create(SingleOnSubscribe)

fromObservable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> fromObservable(@NonNull ObservableSource<? extends T> observable)

Wraps a specific ObservableSource into a Single and signals its single element or error.

If the ObservableSource is empty, a NoSuchElementException is signaled. If the source has more than one element, an IndexOutOfBoundsException is signaled.

Scheduler:

fromObservable does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of the item emitted by the Single.

Parameters:

observable - the source sequence to wrap, not null

Returns:

the new Single instance

Throws:

NullPointerException - if observable is null

fromSupplier

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> fromSupplier(@NonNull Supplier<? extends T> supplier)

Returns a Single that invokes passed supplier and emits its result for each individual SingleObserver that subscribes.

Allows you to defer execution of passed function until a SingleObserver subscribes to the Single. It makes passed function "lazy". Result of the function invocation will be emitted by the Single.

Scheduler:

fromSupplier does not operate by default on a particular Scheduler.

Error handling:

If the Supplier throws an exception, the respective Throwable is delivered to the downstream via SingleObserver.onError(Throwable), except when the downstream has disposed this Single source. In this latter case, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) as an UndeliverableException.

Type Parameters:

T - the type of the item emitted by the Single.

Parameters:

supplier - function which execution should be deferred, it will be invoked when SingleObserver subscribes to the Single.

Returns:

the new Single whose SingleObservers' subscriptions trigger an invocation of the given function.

Throws:

NullPointerException - if supplier is null

Since:

3.0.0

See Also:

defer(Supplier), fromCallable(Callable)

just

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<T> just(T item)

Returns a Single that emits a specified item.

To convert any object into a Single that emits that object, pass that object into the just method.

Scheduler:

just does not operate by default on a particular Scheduler.

Type Parameters:

T - the type of that item

Parameters:

item - the item to emit

Returns:

the new Single that emits item

Throws:

NullPointerException - if item is null

See Also:

ReactiveX operators documentation: Just

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> merge(@NonNull Iterable<? extends SingleSource<? extends T>> sources)

Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source SingleSources signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source SingleSources are disposed. If more than one SingleSource signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Iterable) to merge sources and terminate only when all source SingleSources have completed or failed with an error.

Type Parameters:

T - the common and resulting value type

Parameters:

sources - the Iterable sequence of SingleSource sources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

See Also:

mergeDelayError(Iterable)

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> merge(@NonNull Publisher<? extends SingleSource<? extends T>> sources)

Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, running all SingleSources at once.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source SingleSources signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source SingleSources are disposed. If more than one SingleSource signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(Publisher) to merge sources and terminate only when all source SingleSources have completed or failed with an error.

Type Parameters:

T - the common and resulting value type

Parameters:

sources - the Publisher emitting a sequence of SingleSources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.0

See Also:

mergeDelayError(Publisher)

merge

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> merge(@NonNull SingleSource<? extends SingleSource<? extends 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.

Scheduler:

merge does not operate by default on a particular Scheduler.

The resulting Single emits the outer source's or the inner SingleSource's Throwable as is. Unlike the other merge() operators, this operator won't and can't produce a CompositeException because there is only one possibility for the outer or the inner SingleSource to emit an onError signal. Therefore, there is no need for a mergeDelayError(SingleSource<SingleSource<T>>) operator.

Type Parameters:

T - the value type of the sources and the output

Parameters:

source - a Single that emits a Single

Returns:

the new Single that emits the item that is the result of flattening the Single emitted by source

Throws:

NullPointerException - if source is null

See Also:

ReactiveX operators documentation: Merge

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> merge(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2)

Flattens two SingleSources into one Flowable sequence, without any transformation.

You can combine items emitted by multiple SingleSources so that they appear as a single Flowable, by using the merge method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source SingleSources signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source SingleSources are disposed. If more than one SingleSource signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(SingleSource, SingleSource) to merge sources and terminate only when all source SingleSources have completed or failed with an error.

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be merged

source2 - a SingleSource to be merged

Returns:

the new Flowable that emits all of the items emitted by the source SingleSources

Throws:

NullPointerException - if source1 or source2 is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(SingleSource, SingleSource)

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> merge(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2,
        @NonNull SingleSource<? extends T> source3)

Flattens three SingleSources into one Flowable sequence, without any transformation.

You can combine items emitted by multiple SingleSources so that they appear as a single Flowable, by the merge method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source SingleSources signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source SingleSources are disposed. If more than one SingleSource signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(SingleSource, SingleSource, SingleSource) to merge sources and terminate only when all source SingleSources have completed or failed with an error.

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be merged

source2 - a SingleSource to be merged

source3 - a SingleSource to be merged

Returns:

the new Flowable that emits all of the items emitted by the source SingleSources

Throws:

NullPointerException - if source1, source2 or source3 is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(SingleSource, SingleSource, SingleSource)

merge

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> merge(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2,
        @NonNull SingleSource<? extends T> source3,
        @NonNull SingleSource<? extends T> source4)

Flattens four SingleSources into one Flowable sequence, without any transformation.

You can combine items emitted by multiple SingleSources so that they appear as a single Flowable, by the merge method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

merge does not operate by default on a particular Scheduler.

Error handling:

If any of the source SingleSources signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source SingleSources are disposed. If more than one SingleSource signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. Use mergeDelayError(SingleSource, SingleSource, SingleSource, SingleSource) to merge sources and terminate only when all source SingleSources have completed or failed with an error.

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be merged

source2 - a SingleSource to be merged

source3 - a SingleSource to be merged

source4 - a SingleSource to be merged

Returns:

the new Flowable that emits all of the items emitted by the source SingleSources

Throws:

NullPointerException - if source1, source2, source3 or source4 is null

See Also:

ReactiveX operators documentation: Merge, mergeDelayError(SingleSource, SingleSource, SingleSource, SingleSource)

mergeArray

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T> @NonNull Flowable<T> mergeArray(SingleSource<? extends T>... sources)

Merges an array of SingleSource instances into a single Flowable sequence, running all SingleSources at once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeArray does not operate by default on a particular Scheduler.

Error handling:

If any of the source SingleSources signal a Throwable via onError, the resulting Flowable terminates with that Throwable and all other source SingleSources are disposed. If more than one SingleSource signals an error, the resulting Flowable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with a CompositeException containing two or more of the various error signals. Throwables that didn't make into the composite will be sent (individually) to the global error handler via RxJavaPlugins.onError(Throwable) method as UndeliverableException errors. Similarly, Throwables signaled by source(s) after the returned Flowable has been cancelled or terminated with a (composite) error will be sent to the same global error handler. Use mergeArrayDelayError(SingleSource...) to merge sources and terminate only when all source SingleSources have completed or failed with an error.

Type Parameters:

T - the common and resulting value type

Parameters:

sources - the array sequence of SingleSource sources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

See Also:

mergeArrayDelayError(SingleSource...)

mergeArrayDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @SafeVarargs
 @NonNull
public static <T> @NonNull Flowable<T> mergeArrayDelayError(@NonNull SingleSource<? extends 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.

This behaves like merge(Publisher) except that if any of the merged SingleSources notify of an error via onError, mergeArrayDelayError will refrain from propagating that error notification until all of the merged SingleSources have finished emitting items.

Even if multiple merged SingleSources send onError notifications, mergeArrayDelayError will only invoke the onError method of its subscribers once.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

mergeArrayDelayError does not operate by default on a particular Scheduler.

Type Parameters:

T - the common element base type

Parameters:

sources - the array of SingleSources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

See Also:

ReactiveX operators documentation: Merge

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Iterable<? extends SingleSource<? extends 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.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

History: 2.1.9 - experimental

Type Parameters:

T - the common and resulting value type

Parameters:

sources - the Iterable sequence of SingleSources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.2

See Also:

merge(Iterable)

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

History: 2.1.9 - experimental

Type Parameters:

T - the common and resulting value type

Parameters:

sources - the Flowable sequence of SingleSources

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

2.2

See Also:

merge(Publisher)

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2)

Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.

You can combine items emitted by multiple SingleSources so that they appear as one Flowable, by using the mergeDelayError method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

History: 2.1.9 - experimental

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be merged

source2 - a SingleSource to be merged

Returns:

the new Flowable that emits all of the items emitted by the source SingleSources

Throws:

NullPointerException - if source1 or source2 is null

Since:

2.2

See Also:

ReactiveX operators documentation: Merge, merge(SingleSource, SingleSource)

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2,
        @NonNull SingleSource<? extends T> source3)

Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.

You can combine items emitted by multiple SingleSources so that they appear as one Flowable, by the mergeDelayError method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

History: 2.1.9 - experimental

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be merged

source2 - a SingleSource to be merged

source3 - a SingleSource to be merged

Returns:

the new Flowable that emits all of the items emitted by the source SingleSources

Throws:

NullPointerException - if source1, source2 or source3 is null

Since:

2.2

See Also:

ReactiveX operators documentation: Merge, merge(SingleSource, SingleSource, SingleSource)

mergeDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> mergeDelayError(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2,
        @NonNull SingleSource<? extends T> source3,
        @NonNull SingleSource<? extends T> source4)

Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.

You can combine items emitted by multiple SingleSources so that they appear as one Flowable, by the mergeDelayError method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

mergeDelayError does not operate by default on a particular Scheduler.

History: 2.1.9 - experimental

Type Parameters:

T - the common value type

Parameters:

source1 - a SingleSource to be merged

source2 - a SingleSource to be merged

source3 - a SingleSource to be merged

source4 - a SingleSource to be merged

Returns:

the new Flowable that emits all of the items emitted by the source SingleSources

Throws:

NullPointerException - if source1, source2, source3 or source4 is null

Since:

2.2

See Also:

ReactiveX operators documentation: Merge, merge(SingleSource, SingleSource, SingleSource, SingleSource)

never

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<T> never()

Returns a singleton instance of a never-signaling Single (only calls onSubscribe).

Scheduler:

never does not operate by default on a particular Scheduler.

Type Parameters:

T - the target value type

Returns:

the singleton never instance

Since:

2.0

timer

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public static @NonNull Single<Long> timer(long delay,
        @NonNull TimeUnit unit)

Signals success with 0L value after the given delay when a SingleObserver subscribes.

Scheduler:

timer operates by default on the computation Scheduler.

Parameters:

delay - the delay amount

unit - the time unit of the delay

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

2.0

timer

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public static @NonNull Single<Long> timer(long delay,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Signals success with 0L value on the specified Scheduler after the given delay when a SingleObserver subscribes.

Scheduler:

you specify the Scheduler to signal on.

Parameters:

delay - the delay amount

unit - the time unit of the delay

scheduler - the Scheduler where the single 0L will be emitted

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null, or if scheduler is null

Since:

2.0

sequenceEqual

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<Boolean> sequenceEqual(@NonNull SingleSource<? extends T> source1,
        @NonNull SingleSource<? extends T> source2)

Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).

Scheduler:

sequenceEqual does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

Parameters:

source1 - the first SingleSource instance

source2 - the second SingleSource instance

Returns:

the new Single instance

Throws:

NullPointerException - if source1 or source2 is null

Since:

2.0

switchOnNext

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> switchOnNext(@NonNull Publisher<? extends SingleSource<? extends 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.

Backpressure:

The sources Publisher is consumed in an unbounded manner (requesting Long.MAX_VALUE). The returned Flowable respects the backpressure from the downstream.

Scheduler:

switchOnNext does not operate by default on a particular Scheduler.

Error handling:

The returned sequence fails with the first error signaled by the sources Publisher or the currently running SingleSource, disposing the rest. Late errors are forwarded to the global error handler via RxJavaPlugins.onError(Throwable).

Type Parameters:

T - the element type of the SingleSources

Parameters:

sources - the Publisher sequence of inner SingleSources to switch between

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

3.0.0

See Also:

switchOnNextDelayError(Publisher), ReactiveX operators documentation: Switch

switchOnNextDelayError

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Flowable<T> switchOnNextDelayError(@NonNull Publisher<? extends SingleSource<? extends 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.

Backpressure:

The sources Publisher is consumed in an unbounded manner (requesting Long.MAX_VALUE). The returned Flowable respects the backpressure from the downstream.

Scheduler:

switchOnNextDelayError does not operate by default on a particular Scheduler.

Error handling:

The returned Flowable collects all errors emitted by either the sources Publisher or any inner SingleSource and emits them as a CompositeException when all sources terminate. If only one source ever failed, its error is emitted as-is at the end.

Type Parameters:

T - the element type of the SingleSources

Parameters:

sources - the Publisher sequence of inner SingleSources to switch between

Returns:

the new Flowable instance

Throws:

NullPointerException - if sources is null

Since:

3.0.0

See Also:

switchOnNext(Publisher), ReactiveX operators documentation: Switch

unsafeCreate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> unsafeCreate(@NonNull SingleSource<T> onSubscribe)

Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.

Scheduler:

unsafeCreate does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

onSubscribe - the function that is called with the subscribing SingleObserver

Returns:

the new Single instance

Throws:

NullPointerException - if onSubscribe is null

IllegalArgumentException - if source is a subclass of Single; such instances don't need conversion and is possibly a port remnant from 1.x or one should use hide() instead.

Since:

2.0

using

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T,U> @NonNull Single<T> using(@NonNull Supplier<U> resourceSupplier,
        @NonNull Function<? super U,? extends SingleSource<? extends T>> sourceSupplier,
        @NonNull Consumer<? super U> resourceCleanup)

Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the SingleSource generated

U - the resource type

Parameters:

resourceSupplier - the Supplier called for each SingleObserver to generate a resource object

sourceSupplier - the function called with the returned resource object from resourceSupplier and should return a SingleSource instance to be run by the operator

resourceCleanup - the consumer of the generated resource that is called exactly once for that particular resource when the generated SingleSource terminates (successfully or with an error) or gets disposed.

Returns:

the new Single instance

Throws:

NullPointerException - if resourceSupplier, sourceSupplier and resourceCleanup is null

Since:

2.0

using

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,U> @NonNull Single<T> using(@NonNull Supplier<U> resourceSupplier,
        @NonNull Function<? super U,? extends SingleSource<? extends T>> sourceSupplier,
        @NonNull Consumer<? super 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).

Scheduler:

using does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type of the SingleSource generated

U - the resource type

Parameters:

resourceSupplier - the Supplier called for each SingleObserver to generate a resource object

sourceSupplier - the function called with the returned resource object from resourceSupplier and should return a SingleSource instance to be run by the operator

resourceCleanup - the consumer of the generated resource that is called exactly once for that particular resource when the generated SingleSource terminates (successfully or with an error) or gets disposed.

eager - If true then resource disposal will happen either on a dispose() call before the upstream is disposed or just before the emission of a terminal event (onSuccess or onError). If false the resource disposal will happen either on a dispose() call after the upstream is disposed or just after the emission of a terminal event (onSuccess or onError).

Returns:

the new Single instance

Throws:

NullPointerException - if resourceSupplier, sourceSupplier or resourceCleanup is null

Since:

2.0

wrap

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T> @NonNull Single<T> wrap(@NonNull SingleSource<T> source)

Wraps a SingleSource instance into a new Single instance if not already a Single instance.

Scheduler:

wrap does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

source - the source to wrap

Returns:

the new Single instance

Throws:

NullPointerException - if source is null

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T,R> @NonNull Single<R> zip(@NonNull Iterable<? extends SingleSource<? extends T>> sources,
        @NonNull Function<? super Object[],? extends 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.

If the Iterable of SingleSources is empty a NoSuchElementException error is signaled after subscription.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the SingleSources signal an error, all other SingleSources get disposed and the error emitted to downstream immediately.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

R - the result value type

Parameters:

sources - the Iterable sequence of SingleSource instances. An empty sequence will result in an onError signal of NoSuchElementException.

zipper - the function that receives an array with values from each SingleSource and should return a value to be emitted to downstream

Returns:

the new Single instance

Throws:

NullPointerException - if zipper or sources is null

Since:

2.0

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull BiFunction<? super T1,? super T2,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull Function3<? super T1,? super T2,? super T3,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull SingleSource<? extends T4> source4,
        @NonNull Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

T4 - the fourth source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

source4 - a fourth source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3, source4 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull SingleSource<? extends T4> source4,
        @NonNull SingleSource<? extends T5> source5,
        @NonNull Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

T4 - the fourth source SingleSource's value type

T5 - the fifth source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

source4 - a fourth source SingleSource

source5 - a fifth source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3, source4 source5 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull SingleSource<? extends T4> source4,
        @NonNull SingleSource<? extends T5> source5,
        @NonNull SingleSource<? extends T6> source6,
        @NonNull Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

T4 - the fourth source SingleSource's value type

T5 - the fifth source SingleSource's value type

T6 - the sixth source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

source4 - a fourth source SingleSource

source5 - a fifth source SingleSource

source6 - a sixth source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3, source4 source5, source6 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull SingleSource<? extends T4> source4,
        @NonNull SingleSource<? extends T5> source5,
        @NonNull SingleSource<? extends T6> source6,
        @NonNull SingleSource<? extends T7> source7,
        @NonNull Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

T4 - the fourth source SingleSource's value type

T5 - the fifth source SingleSource's value type

T6 - the sixth source SingleSource's value type

T7 - the seventh source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

source4 - a fourth source SingleSource

source5 - a fifth source SingleSource

source6 - a sixth source SingleSource

source7 - a seventh source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3, source4 source5, source6, source7 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull SingleSource<? extends T4> source4,
        @NonNull SingleSource<? extends T5> source5,
        @NonNull SingleSource<? extends T6> source6,
        @NonNull SingleSource<? extends T7> source7,
        @NonNull SingleSource<? extends T8> source8,
        @NonNull Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

T4 - the fourth source SingleSource's value type

T5 - the fifth source SingleSource's value type

T6 - the sixth source SingleSource's value type

T7 - the seventh source SingleSource's value type

T8 - the eighth source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

source4 - a fourth source SingleSource

source5 - a fifth source SingleSource

source6 - a sixth source SingleSource

source7 - a seventh source SingleSource

source8 - an eighth source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3, source4 source5, source6, source7, source8 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zip

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> @NonNull Single<R> zip(@NonNull SingleSource<? extends T1> source1,
        @NonNull SingleSource<? extends T2> source2,
        @NonNull SingleSource<? extends T3> source3,
        @NonNull SingleSource<? extends T4> source4,
        @NonNull SingleSource<? extends T5> source5,
        @NonNull SingleSource<? extends T6> source6,
        @NonNull SingleSource<? extends T7> source7,
        @NonNull SingleSource<? extends T8> source8,
        @NonNull SingleSource<? extends T9> source9,
        @NonNull Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)

Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other SingleSources.

Scheduler:

zip does not operate by default on a particular Scheduler.

Type Parameters:

T1 - the first source SingleSource's value type

T2 - the second source SingleSource's value type

T3 - the third source SingleSource's value type

T4 - the fourth source SingleSource's value type

T5 - the fifth source SingleSource's value type

T6 - the sixth source SingleSource's value type

T7 - the seventh source SingleSource's value type

T8 - the eighth source SingleSource's value type

T9 - the ninth source SingleSource's value type

R - the result value type

Parameters:

source1 - the first source SingleSource

source2 - a second source SingleSource

source3 - a third source SingleSource

source4 - a fourth source SingleSource

source5 - a fifth source SingleSource

source6 - a sixth source SingleSource

source7 - a seventh source SingleSource

source8 - an eighth source SingleSource

source9 - a ninth source SingleSource

zipper - a function that, when applied to the item emitted by each of the source SingleSources, results in an item that will be emitted by the resulting Single

Returns:

the new Single that emits the zipped results

Throws:

NullPointerException - if source1, source2, source3, source4 source5, source6, source7, source8, source9 or zipper is null

See Also:

ReactiveX operators documentation: Zip

zipArray

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @SafeVarargs
public static <T,R> @NonNull Single<R> zipArray(@NonNull Function<? super Object[],? extends R> zipper,
        @NonNull SingleSource<? extends 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.

If the array of SingleSources is empty a NoSuchElementException error is signaled immediately.

Note on method signature: since Java doesn't allow creating a generic array with new T[], the implementation of this operator has to create an Object[] instead. Unfortunately, a Function<Integer[], R> passed to the method would trigger a ClassCastException.

If any of the SingleSources signal an error, all other SingleSources get disposed and the error emitted to downstream immediately.

Scheduler:

zipArray does not operate by default on a particular Scheduler.

Type Parameters:

T - the common value type

R - the result value type

Parameters:

sources - the array of SingleSource instances. An empty sequence will result in an onError signal of NoSuchElementException.

zipper - the function that receives an array with values from each SingleSource and should return a value to be emitted to downstream

Returns:

the new Single instance

Throws:

NullPointerException - if zipper or sources is null

Since:

2.0

ambWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> ambWith(@NonNull SingleSource<? extends T> other)

Signals the event of this or the other SingleSource whichever signals first.

Scheduler:

ambWith does not operate by default on a particular Scheduler.

Parameters:

other - the other SingleSource to race for the first emission of success or error

Returns:

the new Single instance. A subscription to this provided source will occur after subscribing to the current source.

Throws:

NullPointerException - if other is null

Since:

2.0

hide

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> hide()

Hides the identity of the current Single, including the Disposable that is sent to the downstream via onSubscribe().

Scheduler:

hide does not operate by default on a particular Scheduler.

Returns:

the new Single instance

Since:

2.0

compose

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Single<R> compose(@NonNull SingleTransformer<? super T,? extends R> transformer)

Transform a Single by applying a particular SingleTransformer function to it.

This method operates on the Single itself whereas lift(io.reactivex.rxjava3.core.SingleOperator<? extends R, ? super T>) operates on SingleObservers.

If the operator you are creating is designed to act on the individual item emitted by a Single, use lift(io.reactivex.rxjava3.core.SingleOperator<? extends R, ? super T>). If your operator is designed to transform the current Single as a whole (for instance, by applying a particular set of existing RxJava operators to it) use compose.

Scheduler:

compose does not operate by default on a particular Scheduler.

Type Parameters:

R - the value type of the single returned by the transformer function

Parameters:

transformer - the transformer function, not null

Returns:

the new Single instance

Throws:

NullPointerException - if transformer is null

See Also:

RxJava wiki: Implementing Your Own Operators

cache

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> cache()

Stores the success value or exception from the current Single and replays it to late SingleObservers.

The returned Single subscribes to the current Single when the first SingleObserver subscribes.

Scheduler:

cache does not operate by default on a particular Scheduler.

Returns:

the new Single instance

Since:

2.0

cast

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Single<U> cast(@NonNull Class<? extends U> clazz)

Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.

Scheduler:

cast does not operate by default on a particular Scheduler.

Type Parameters:

U - the target type

Parameters:

clazz - the type token to use for casting the success result from the current Single

Returns:

the new Single instance

Throws:

NullPointerException - if clazz is null

Since:

2.0

concatMap

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Single<R> concatMap(@NonNull Function<? super T,? extends SingleSource<? extends 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.

The operator is an alias for flatMap(Function)

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a SingleSource

Returns:

the new Single returned from mapper when applied to the item emitted by the current Single

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap

concatMapCompletable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable concatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.

The operator is an alias for flatMapCompletable(Function).

Scheduler:

concatMapCompletable does not operate by default on a particular Scheduler.

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a CompletableSource

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap

concatMapMaybe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Maybe<R> concatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.

The operator is an alias for flatMapMaybe(Function).

Scheduler:

concatMapMaybe does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a MaybeSource

Returns:

the new Maybe returned from mapper when applied to the item emitted by the current Single

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap

concatWith

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> concatWith(@NonNull SingleSource<? extends T> other)

Returns a Flowable that emits the item emitted by the current Single, then the item emitted by the specified SingleSource.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

concatWith does not operate by default on a particular Scheduler.

Parameters:

other - a SingleSource to be concatenated after the current

Returns:

the new Flowable that emits the item emitted by the current Single, followed by the item emitted by other

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: Concat

delay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Single<T> delay(long time,
        @NonNull TimeUnit unit)

Delays the emission of the success signal from the current Single by the specified amount. An error signal will not be delayed.

Scheduler:

delay operates by default on the computation Scheduler.

Parameters:

time - the amount of time the success signal should be delayed for

unit - the time unit

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

2.0

See Also:

delay(long, TimeUnit, boolean)

delay

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Single<T> delay(long time,
        @NonNull TimeUnit unit,
        boolean delayError)

Delays the emission of the success or error signal from the current Single by the specified amount.

Scheduler:

delay operates by default on the computation Scheduler.

History: 2.1.5 - experimental

Parameters:

time - the amount of time the success or error signal should be delayed for

unit - the time unit

delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

2.2

delay

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Single<T> delay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Delays the emission of the success signal from the current Single by the specified amount. An error signal will not be delayed.

Scheduler:

you specify the Scheduler where the non-blocking wait and emission happens

Parameters:

time - the amount of time the success signal should be delayed for

unit - the time unit

scheduler - the target scheduler to use for the non-blocking wait and emission

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null, or if scheduler is null

Since:

2.0

See Also:

delay(long, TimeUnit, Scheduler, boolean)

delay

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<T> delay(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        boolean delayError)

Delays the emission of the success or error signal from the current Single by the specified amount.

Scheduler:

you specify the Scheduler where the non-blocking wait and emission happens

History: 2.1.5 - experimental

Parameters:

time - the amount of time the success or error signal should be delayed for

unit - the time unit

scheduler - the target scheduler to use for the non-blocking wait and emission

delayError - if true, both success and error signals are delayed. if false, only success signals are delayed.

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null, or if scheduler is null

Since:

2.2

delaySubscription

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> delaySubscription(@NonNull CompletableSource subscriptionIndicator)

Delays the actual subscription to the current Single until the given other CompletableSource completes.

If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.

Scheduler:

delaySubscription does not operate by default on a particular Scheduler.

Parameters:

subscriptionIndicator - the CompletableSource that has to complete before the subscription to the current Single happens

Returns:

the new Single instance

Throws:

NullPointerException - if subscriptionIndicator is null

Since:

2.0

delaySubscription

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Single<T> delaySubscription(@NonNull SingleSource<U> subscriptionIndicator)

Delays the actual subscription to the current Single until the given other SingleSource signals success.

If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.

Scheduler:

delaySubscription does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the other source

Parameters:

subscriptionIndicator - the SingleSource that has to complete before the subscription to the current Single happens

Returns:

the new Single instance

Throws:

NullPointerException - if subscriptionIndicator is null

Since:

2.0

delaySubscription

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Single<T> delaySubscription(@NonNull ObservableSource<U> subscriptionIndicator)

Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.

If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.

Scheduler:

delaySubscription does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the other source

Parameters:

subscriptionIndicator - the ObservableSource that has to signal a value or complete before the subscription to the current Single happens

Returns:

the new Single instance

Throws:

NullPointerException - if subscriptionIndicator is null

Since:

2.0

delaySubscription

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Single<T> delaySubscription(@NonNull Publisher<U> subscriptionIndicator)

Delays the actual subscription to the current Single until the given other Publisher signals its first value or completes.

If the delaying source signals an error, that error is re-emitted and no subscription to the current Single happens.

The other source is consumed in an unbounded manner (requesting Long.MAX_VALUE from it).

Backpressure:

The other publisher is consumed in an unbounded fashion but will be cancelled after the first item it produced.

Scheduler:

delaySubscription does not operate by default on a particular Scheduler.

Type Parameters:

U - the element type of the other source

Parameters:

subscriptionIndicator - the Publisher that has to signal a value or complete before the subscription to the current Single happens

Returns:

the new Single instance

Throws:

NullPointerException - if subscriptionIndicator is null

Since:

2.0

delaySubscription

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Single<T> delaySubscription(long time,
        @NonNull TimeUnit unit)

Delays the actual subscription to the current Single until the given time delay elapsed.

Scheduler:

delaySubscription does by default subscribe to the current Single on the computation Scheduler after the delay.

Parameters:

time - the time amount to wait with the subscription

unit - the time unit of the waiting

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

2.0

delaySubscription

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Single<T> delaySubscription(long time,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Delays the actual subscription to the current Single until the given time delay elapsed.

Scheduler:

delaySubscription does by default subscribe to the current Single on the Scheduler you provided, after the delay.

Parameters:

time - the time amount to wait with the subscription

unit - the time unit of the waiting

scheduler - the Scheduler to wait on and subscribe on to the current Single

Returns:

the new Single instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

2.0

dematerialize

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Maybe<R> dematerialize(@NonNull Function<? super T,Notification<R>> selector)

Maps the Notification success value of the current Single back into normal onSuccess, onError or onComplete signals as a Maybe source.

The intended use of the selector function is to perform a type-safe identity mapping (see example) on a source that is already of type Notification<T>. The Java language doesn't allow limiting instance methods to a certain generic argument shape, therefore, a function is used to ensure the conversion remains type safe.

Scheduler:

dematerialize does not operate by default on a particular Scheduler.

Example:

 Single.just(Notification.createOnNext(1))
 .dematerialize(notification -> notification)
 .test()
 .assertResult(1);
 

History: 2.2.4 - experimental

Type Parameters:

R - the result type

Parameters:

selector - the function called with the success item and should return a Notification instance.

Returns:

the new Maybe instance

Throws:

NullPointerException - if selector is null

Since:

3.0.0

See Also:

materialize()

doAfterSuccess

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doAfterSuccess(@NonNull Consumer<? super T> onAfterSuccess)

Calls the specified consumer with the success item after this item has been emitted to the downstream.

Note that the doAfterSuccess action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doAfterSuccess does not operate by default on a particular Scheduler.

History: 2.0.1 - experimental

Parameters:

onAfterSuccess - the Consumer that will be called after emitting an item from upstream to the downstream

Returns:

the new Single instance

Throws:

NullPointerException - if onAfterSuccess is null

Since:

2.1

doAfterTerminate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doAfterTerminate(@NonNull Action onAfterTerminate)

Registers an Action to be called after this Single invokes either onSuccess or onError.

Note that the doAfterTerminate action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doAfterTerminate does not operate by default on a particular Scheduler.

History: 2.0.6 - experimental

Parameters:

onAfterTerminate - an Action to be invoked when the current Single finishes

Returns:

the new Single that emits the same items as the current Single, then invokes the Action

Throws:

NullPointerException - if onAfterTerminate is null

Since:

2.1

See Also:

ReactiveX operators documentation: Do

doFinally

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doFinally(@NonNull Action onFinally)

Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.

In case of a race between a terminal event and a dispose call, the provided onFinally action is executed once per subscription.

Note that the onFinally action is shared between subscriptions and as such should be thread-safe.

Scheduler:

doFinally does not operate by default on a particular Scheduler.

History: 2.0.1 - experimental

Parameters:

onFinally - the action called when this Single terminates or gets disposed

Returns:

the new Single instance

Throws:

NullPointerException - if onFinally is null

Since:

2.1

doOnLifecycle

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe,
        @NonNull Action onDispose)

Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).

Scheduler:

doOnLifecycle does not operate by default on a particular Scheduler.

Parameters:

onSubscribe - a Consumer called with the Disposable sent via SingleObserver.onSubscribe(Disposable)

onDispose - called when the downstream disposes the Disposable via dispose()

Returns:

the new Single instance

Throws:

NullPointerException - if onSubscribe or onDispose is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: Do

doOnSubscribe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)

Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.

Scheduler:

doOnSubscribe does not operate by default on a particular Scheduler.

Parameters:

onSubscribe - the consumer called with the Disposable sent via onSubscribe

Returns:

the new Single instance

Throws:

NullPointerException - if onSubscribe is null

Since:

2.0

doOnTerminate

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doOnTerminate(@NonNull Action onTerminate)

Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.

This differs from doAfterTerminate in that this happens before the onSuccess or onError notification.

Scheduler:

doOnTerminate does not operate by default on a particular Scheduler.

History: 2.2.7 - experimental

Parameters:

onTerminate - the action to invoke when the consumer calls onSuccess or onError

Returns:

the new Single instance

Throws:

NullPointerException - if onTerminate is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: Do, doOnTerminate(Action)

doOnSuccess

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doOnSuccess(@NonNull Consumer<? super T> onSuccess)

Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.

Scheduler:

doOnSuccess does not operate by default on a particular Scheduler.

Parameters:

onSuccess - the consumer called with the success value of onSuccess

Returns:

the new Single instance

Throws:

NullPointerException - if onSuccess is null

Since:

2.0

doOnEvent

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doOnEvent(@NonNull BiConsumer<? super T,? super Throwable> onEvent)

Calls the shared consumer with the error sent via onError or the value via onSuccess for each SingleObserver that subscribes to the current Single.

Scheduler:

doOnEvent does not operate by default on a particular Scheduler.

Parameters:

onEvent - the consumer called with the success value of onEvent

Returns:

the new Single instance

Throws:

NullPointerException - if onEvent is null

Since:

2.0

doOnError

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doOnError(@NonNull Consumer<? super Throwable> onError)

Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.

Scheduler:

doOnError does not operate by default on a particular Scheduler.

Parameters:

onError - the consumer called with the success value of onError

Returns:

the new Single instance

Throws:

NullPointerException - if onError is null

Since:

2.0

doOnDispose

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> doOnDispose(@NonNull Action onDispose)

Calls the shared Action if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.

Scheduler:

doOnDispose does not operate by default on a particular Scheduler.

Parameters:

onDispose - the action called when the subscription is disposed

Returns:

the new Single instance

Throws:

NullPointerException - if onDispose is null

Since:

2.0

filter

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Maybe<T> filter(@NonNull Predicate<? super T> predicate)

Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.

Scheduler:

filter does not operate by default on a particular Scheduler.

Parameters:

predicate - a function that evaluates the item emitted by the current Single, returning true if it passes the filter

Returns:

the new Maybe that emit the item emitted by the current Single that the filter evaluates as true

Throws:

NullPointerException - if predicate is null

See Also:

ReactiveX operators documentation: Filter

flatMap

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Single<R> flatMap(@NonNull Function<? super T,? extends SingleSource<? extends 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.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a SingleSource

Returns:

the new Single returned from mapper when applied to the item emitted by the current Single

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U,R> @NonNull Single<R> flatMap(@NonNull Function<? super T,? extends SingleSource<? extends U>> mapper,
        @NonNull BiFunction<? super T,? super U,? extends 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.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the SingleSource returned by the mapper function

R - the type of items emitted by the resulting Single

Parameters:

mapper - a function that returns a SingleSource for the item emitted by the current Single

combiner - a function that combines one item emitted by each of the source and collection SingleSource and returns an item to be emitted by the resulting SingleSource

Returns:

the new Single instance

Throws:

NullPointerException - if mapper or combiner is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap

flatMap

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Single<R> flatMap(@NonNull Function<? super T,? extends SingleSource<? extends R>> onSuccessMapper,
        @NonNull Function<? super Throwable,? extends SingleSource<? extends R>> onErrorMapper)

Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

onSuccessMapper - a function that returns a SingleSource to merge for the onSuccess item emitted by this Single

onErrorMapper - a function that returns a SingleSource to merge for an onError notification from this Single

Returns:

the new Single instance

Throws:

NullPointerException - if onSuccessMapper or onErrorMapper is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap

flatMapMaybe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Maybe<R> flatMapMaybe(@NonNull Function<? super T,? extends MaybeSource<? extends R>> mapper)

Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.

Scheduler:

flatMapMaybe does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a MaybeSource

Returns:

the new Maybe returned from mapper when applied to the item emitted by the current Single

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flatMapPublisher

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Flowable<R> flatMapPublisher(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Single, where that function returns a Publisher.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer and the Publisher returned by the mapper function is expected to honor it as well.

Scheduler:

flatMapPublisher does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a Publisher

Returns:

the new Flowable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flattenAsFlowable

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Flowable<U> flattenAsFlowable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Maps the success value of the current Single into an Iterable and emits its items as a Flowable sequence.

Backpressure:

The operator honors backpressure from downstream.

Scheduler:

flattenAsFlowable does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of item emitted by the resulting Iterable

Parameters:

mapper - a function that returns an Iterable sequence of values for when given an item emitted by the current Single

Returns:

the new Flowable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap, flattenStreamAsFlowable(Function)

flattenAsObservable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Observable<U> flattenAsObservable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Maps the success value of the current Single into an Iterable and emits its items as an Observable sequence.

Scheduler:

flattenAsObservable does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of item emitted by the resulting Iterable

Parameters:

mapper - a function that returns an Iterable sequence of values for when given an item emitted by the current Single

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap, flattenStreamAsObservable(Function)

flatMapObservable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Observable<R> flatMapObservable(@NonNull Function<? super T,? extends ObservableSource<? extends 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.

Scheduler:

flatMapObservable does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns an ObservableSource

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: FlatMap

flatMapCompletable

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Completable flatMapCompletable(@NonNull Function<? super T,? extends CompletableSource> mapper)

Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.

Scheduler:

flatMapCompletable does not operate by default on a particular Scheduler.

Parameters:

mapper - a function that, when applied to the item emitted by the current Single, returns a CompletableSource

Returns:

the new Completable instance

Throws:

NullPointerException - if mapper is null

Since:

2.0

See Also:

ReactiveX operators documentation: FlatMap

blockingGet

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final T blockingGet()

Waits in a blocking fashion until the current Single signals a success value (which is returned) or an exception (which is propagated).

Scheduler:

blockingGet does not operate by default on a particular Scheduler.

Error handling:

If the source signals an error, the operator wraps a checked Exception into RuntimeException and throws that. Otherwise, RuntimeExceptions and Errors are rethrown as they are.

Returns:

the success value

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe()

Subscribes to the current Single and blocks the current thread until it terminates.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Error handling:

If the current Single signals an error, the Throwable is routed to the global error handler via RxJavaPlugins.onError(Throwable). If the current thread is interrupted, an InterruptedException is routed to the same global error handler.

Since:

3.0.0

See Also:

blockingSubscribe(Consumer), blockingSubscribe(Consumer, Consumer)

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull Consumer<? super T> onSuccess)

Subscribes to the current Single and calls given onSuccess callback on the current thread when it completes normally.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Error handling:

If either the current Single signals an error or onSuccess throws, the respective Throwable is routed to the global error handler via RxJavaPlugins.onError(Throwable). If the current thread is interrupted, an InterruptedException is routed to the same global error handler.

Parameters:

onSuccess - the Consumer to call if the current Single succeeds

Throws:

NullPointerException - if onSuccess is null

Since:

3.0.0

See Also:

blockingSubscribe(Consumer, Consumer)

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull Consumer<? super T> onSuccess,
        @NonNull Consumer<? super Throwable> onError)

Subscribes to the current Single and calls the appropriate callback on the current thread when it terminates.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Error handling:

If either onSuccess or onError throw, the Throwable is routed to the global error handler via RxJavaPlugins.onError(Throwable). If the current thread is interrupted, the onError consumer is called with an InterruptedException.

Parameters:

onSuccess - the Consumer to call if the current Single succeeds

onError - the Consumer to call if the current Single signals an error

Throws:

NullPointerException - if onSuccess or onError is null

Since:

3.0.0

blockingSubscribe

@SchedulerSupport(value="none")
public final void blockingSubscribe(@NonNull SingleObserver<? super T> observer)

Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread.

Scheduler:

blockingSubscribe does not operate by default on a particular Scheduler.

Error handling:

An onError signal is delivered to the SingleObserver.onError(Throwable) method. If any of the SingleObserver's methods throw, the RuntimeException is propagated to the caller of this method. If the current thread is interrupted, an InterruptedException is delivered to observer.onError.

Parameters:

observer - the SingleObserver to call methods on the current thread

Throws:

NullPointerException - if observer is null

Since:

3.0.0

lift

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Single<R> lift(@NonNull SingleOperator<? extends R,? super T> lift)

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Single which, when subscribed to, invokes the apply(SingleObserver) method of the provided SingleOperator for each individual downstream Single and allows the insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase and providing a new SingleObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

Generally, such a new SingleObserver will wrap the downstream's SingleObserver and forwards the onSuccess and onError events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls of dispose and isDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.

Example:

 // Step 1: Create the consumer type that will be returned by the SingleOperator.apply():

 public final class CustomSingleObserver<T> implements SingleObserver<T>, Disposable {

     // The downstream's SingleObserver that will receive the onXXX events
     final SingleObserver<? super String> downstream;

     // The connection to the upstream source that will call this class' onXXX methods
     Disposable upstream;

     // The constructor takes the downstream subscriber and usually any other parameters
     public CustomSingleObserver(SingleObserver<? super String> downstream) {
         this.downstream = downstream;
     }

     // In the subscription phase, the upstream sends a Disposable to this class
     // and subsequently this class has to send a Disposable to the downstream.
     // Note that relaying the upstream's Disposable directly is not allowed in RxJava
     @Override
     public void onSubscribe(Disposable d) {
         if (upstream != null) {
             d.dispose();
         } else {
             upstream = d;
             downstream.onSubscribe(this);
         }
     }

     // The upstream calls this with the next item and the implementation's
     // responsibility is to emit an item to the downstream based on the intended
     // business logic, or if it can't do so for the particular item,
        // request more from the upstream
     @Override
     public void onSuccess(T item) {
         String str = item.toString();
         if (str.length() < 2) {
             downstream.onSuccess(str);
         } else {
             // Single is usually expected to produce one of the onXXX events
             downstream.onError(new NoSuchElementException());
         }
     }

     // Some operators may handle the upstream's error while others
     // could just forward it to the downstream.
     @Override
     public void onError(Throwable throwable) {
         downstream.onError(throwable);
     }

     // Some operators may use their own resources which should be cleaned up if
     // the downstream disposes the flow before it completed. Operators without
     // resources can simply forward the dispose to the upstream.
     // In some cases, a disposed flag may be set by this method so that other parts
     // of this class may detect the dispose and stop sending events
     // to the downstream.
     @Override
     public void dispose() {
         upstream.dispose();
     }

     // Some operators may simply forward the call to the upstream while others
     // can return the disposed flag set in dispose().
     @Override
     public boolean isDisposed() {
         return upstream.isDisposed();
     }
 }

 // Step 2: Create a class that implements the SingleOperator interface and
 //         returns the custom consumer type from above in its apply() method.
 //         Such class may define additional parameters to be submitted to
 //         the custom consumer type.

 final class CustomSingleOperator<T> implements SingleOperator<String> {
     @Override
     public SingleObserver<? super String> apply(SingleObserver<? super T> upstream) {
         return new CustomSingleObserver<T>(upstream);
     }
 }

 // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it
 //         or reusing an existing one.

 Single.just(5)
 .lift(new CustomSingleOperator<Integer>())
 .test()
 .assertResult("5");

 Single.just(15)
 .lift(new CustomSingleOperator<Integer>())
 .test()
 .assertFailure(NoSuchElementException.class);
 

Creating custom operators can be complicated and it is recommended one consults the RxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.

Note that implementing custom operators via this lift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstract Single class and creating a SingleTransformer with it is recommended.

Note also that it is not possible to stop the subscription phase in lift() as the apply() method requires a non-null SingleObserver instance to be returned, which is then unconditionally subscribed to the current Single. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return a SingleObserver that should immediately dispose the upstream's Disposable in its onSubscribe method. Again, using a SingleTransformer and extending the Single is a better option as subscribeActual(io.reactivex.rxjava3.core.SingleObserver<? super T>) can decide to not subscribe to its upstream after all.

Scheduler:

lift does not operate by default on a particular Scheduler, however, the SingleOperator may use a Scheduler to support its own asynchronous behavior.

Type Parameters:

R - the output value type

Parameters:

lift - the SingleOperator that receives the downstream's SingleObserver and should return a SingleObserver with custom behavior to be used as the consumer for the current Single.

Returns:

the new Single instance

Throws:

NullPointerException - if lift is null

See Also:

RxJava wiki: Writing operators, compose(SingleTransformer)

map

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <R> @NonNull Single<R> map(@NonNull Function<? super T,? extends R> mapper)

Returns a Single that applies a specified function to the item emitted by the current Single and emits the result of this function application.

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

R - the result value type

Parameters:

mapper - a function to apply to the item emitted by the Single

Returns:

the new Single that emits the item from the current Single, transformed by the specified function

Throws:

NullPointerException - if mapper is null

See Also:

ReactiveX operators documentation: Map

materialize

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Notification<T>> materialize()

Maps the signal types of this Single into a Notification of the same kind and emits it as a single success value to downstream.

Scheduler:

materialize does not operate by default on a particular Scheduler.

History: 2.2.4 - experimental

Returns:

the new Single instance

Since:

3.0.0

See Also:

dematerialize(Function)

contains

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<Boolean> contains(@NonNull Object item)

Signals true if the current Single signals a success value that is Object.equals(Object) with the value provided.

Scheduler:

contains does not operate by default on a particular Scheduler.

Parameters:

item - the value to compare against the success value of this Single

Returns:

the new Single instance

Throws:

NullPointerException - if item is null

Since:

2.0

contains

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<Boolean> contains(@NonNull Object item,
        @NonNull BiPredicate<Object,Object> comparer)

Signals true if the current Single signals a success value that is equal with the value provided by calling a BiPredicate.

Scheduler:

contains does not operate by default on a particular Scheduler.

Parameters:

item - the value to compare against the success value of this Single

comparer - the function that receives the success value of this Single, the value provided and should return true if they are considered equal

Returns:

the new Single instance

Throws:

NullPointerException - if item or comparer is null

Since:

2.0

mergeWith

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> mergeWith(@NonNull SingleSource<? extends T> other)

Flattens this Single and another SingleSource into one Flowable, without any transformation.

You can combine items emitted by multiple SingleSources so that they appear as one Flowable, by using the mergeWith method.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

mergeWith does not operate by default on a particular Scheduler.

Parameters:

other - a SingleSource to be merged

Returns:

the new Flowable instance

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: Merge

ofType

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <U> @NonNull Maybe<U> ofType(@NonNull Class<U> clazz)

Filters the items emitted by the current Single, only emitting its success value if that is an instance of the supplied Class.

Scheduler:

ofType does not operate by default on a particular Scheduler.

Type Parameters:

U - the output type

Parameters:

clazz - the class type to filter the items emitted by the current Single

Returns:

the new Maybe instance

Throws:

NullPointerException - if clazz is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: Filter

observeOn

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<T> observeOn(@NonNull Scheduler scheduler)

Signals the success item or the terminal signals of the current Single on the specified Scheduler, asynchronously.

Scheduler:

you specify which Scheduler this operator will use.

Parameters:

scheduler - the Scheduler to notify subscribers on

Returns:

the new Single instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: ObserveOn, RxJava Threading Examples, subscribeOn(io.reactivex.rxjava3.core.Scheduler)

onErrorReturn

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> onErrorReturn(@NonNull Function<Throwable,? extends T> itemSupplier)

Ends the flow with a success item returned by a function for the Throwable error signaled by the current Single instead of signaling the error via onError.

By default, when a Single encounters an error that prevents it from emitting the expected item to its subscriber, the Single invokes its subscriber's SingleObserver.onError(java.lang.Throwable) method, and then quits without invoking any more of its observer's methods. The onErrorReturn method changes this behavior. If you pass a function (resumeFunction) to a Single's onErrorReturn method, if the original Single encounters an error, instead of invoking its observer's SingleObserver.onError(java.lang.Throwable) method, it will instead emit the return value of resumeFunction.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorReturn does not operate by default on a particular Scheduler.

Parameters:

itemSupplier - a function that returns an item that the new Single will emit if the current Single encounters an error

Returns:

the new Single instance

Throws:

NullPointerException - if itemSupplier is null

See Also:

ReactiveX operators documentation: Catch

onErrorReturnItem

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> onErrorReturnItem(@NonNull T item)

Signals the specified value as success in case the current Single signals an error.

Scheduler:

onErrorReturnItem does not operate by default on a particular Scheduler.

Parameters:

item - the value to signal if the current Single fails

Returns:

the new Single instance

Throws:

NullPointerException - if item is null

Since:

2.0

onErrorResumeWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> onErrorResumeWith(@NonNull SingleSource<? extends T> fallback)

Resumes the flow with the given SingleSource when the current Single fails instead of signaling the error via onError.

By default, when a Single encounters an error that prevents it from emitting the expected item to its SingleObserver, the Single invokes its SingleObserver's onError method, and then quits without invoking any more of its SingleObserver's methods. The onErrorResumeWith method changes this behavior. If you pass another Single (resumeSingleInCaseOfError) to a Single's onErrorResumeWith method, if the original Single encounters an error, instead of invoking its SingleObserver's onError method, it will instead relinquish control to resumeSingleInCaseOfError which will invoke the SingleObserver's onSuccess method if it is able to do so. In such a case, because no Single necessarily invokes onError, the SingleObserver may never know that an error happened.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorResumeWith does not operate by default on a particular Scheduler.

Parameters:

fallback - a Single that will take control if source Single encounters an error.

Returns:

the new Single instance

Throws:

NullPointerException - if fallback is null

See Also:

ReactiveX operators documentation: Catch

onErrorComplete

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Maybe<T> onErrorComplete()

Returns a Maybe instance that if the current Single emits an error, it will emit an onComplete and swallow the throwable.

Scheduler:

onErrorComplete does not operate by default on a particular Scheduler.

Returns:

the new Maybe instance

Since:

3.0.0

onErrorComplete

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Maybe<T> onErrorComplete(@NonNull Predicate<? super Throwable> predicate)

Returns a Maybe instance that if this Single emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

Scheduler:

onErrorComplete does not operate by default on a particular Scheduler.

Parameters:

predicate - the predicate to call when an Throwable is emitted which should return true if the Throwable should be swallowed and replaced with an onComplete.

Returns:

the new Maybe instance

Throws:

NullPointerException - if predicate is null

Since:

3.0.0

onErrorResumeNext

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> onErrorResumeNext(@NonNull Function<? super Throwable,? extends SingleSource<? extends 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.

By default, when a Single encounters an error that prevents it from emitting the expected item to its SingleObserver, the Single invokes its SingleObserver's onError method, and then quits without invoking any more of its SingleObserver's methods. The onErrorResumeNext method changes this behavior. If you pass a function that will return another Single (resumeFunctionInCaseOfError) to a Single's onErrorResumeNext method, if the original Single encounters an error, instead of invoking its SingleObserver's onError method, it will instead relinquish control to resumeSingleInCaseOfError which will invoke the SingleObserver's onSuccess method if it is able to do so. In such a case, because no Single necessarily invokes onError, the SingleObserver may never know that an error happened.

You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.

Scheduler:

onErrorResumeNext does not operate by default on a particular Scheduler.

Parameters:

fallbackSupplier - a function that returns a SingleSource that will take control if source Single encounters an error.

Returns:

the new Single instance

Throws:

NullPointerException - if fallbackSupplier is null

Since:

.20

See Also:

ReactiveX operators documentation: Catch

onTerminateDetach

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> onTerminateDetach()

Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().

Scheduler:

onTerminateDetach does not operate by default on a particular Scheduler.

History: 2.1.5 - experimental

Returns:

the new Single which nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose()

Since:

2.2

repeat

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> repeat()

Repeatedly re-subscribes to the current Single and emits each success value as a Flowable sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

repeat does not operate by default on a particular Scheduler.

Returns:

the new Flowable instance

Since:

2.0

repeat

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> repeat(long times)

Re-subscribes to the current Single at most the given number of times and emits each success value as a Flowable sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

repeat does not operate by default on a particular Scheduler.

Parameters:

times - the number of times to re-subscribe to the current Single

Returns:

the new Flowable instance

Throws:

IllegalArgumentException - if times is negative

Since:

2.0

repeatWhen

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> repeatWhen(@NonNull Function<? super Flowable<Object>,? extends Publisher<?>> handler)

Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer. The Publisher returned by the handler function is expected to honor backpressure as well.

Scheduler:

repeatWhen does not operate by default on a particular Scheduler.

Parameters:

handler - the function that is called with a Flowable that signals a value when the Single signaled a success value and returns a Publisher that has to signal a value to trigger a resubscription to the current Single, otherwise the terminal signal of the Publisher will be the terminal signal of the sequence as well.

Returns:

the new Flowable instance

Throws:

NullPointerException - if handler is null

Since:

2.0

repeatUntil

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> repeatUntil(@NonNull BooleanSupplier stop)

Re-subscribes to the current Single until the given BooleanSupplier returns true and emits the success items as a Flowable sequence.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

repeatUntil does not operate by default on a particular Scheduler.

Parameters:

stop - the BooleanSupplier called after the current Single succeeds and if returns false, the Single is re-subscribed; otherwise the sequence completes.

Returns:

the new Flowable instance

Throws:

NullPointerException - if stop is null

Since:

2.0

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> retry()

Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.

Scheduler:

retry does not operate by default on a particular Scheduler.

Returns:

the new Single instance

Since:

2.0

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> retry(long times)

Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

times - the number of times to resubscribe if the current Single fails

Returns:

the new Single instance

Throws:

IllegalArgumentException - if times is negative

Since:

2.0

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> retry(@NonNull BiPredicate<? super Integer,? super Throwable> predicate)

Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

predicate - the predicate called with the resubscription count and the failure Throwable and should return true if a resubscription should happen

Returns:

the new Single instance

Throws:

NullPointerException - if predicate is null

Since:

2.0

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> retry(long times,
        @NonNull Predicate<? super Throwable> predicate)

Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first if it fails with an onError.

Scheduler:

retry does not operate by default on a particular Scheduler.

History: 2.1.8 - experimental

Parameters:

times - the number of times to resubscribe if the current Single fails

predicate - the predicate called with the failure Throwable and should return true if a resubscription should happen

Returns:

the new Single instance

Throws:

NullPointerException - if predicate is null

IllegalArgumentException - if times is negative

Since:

2.2

retry

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> retry(@NonNull Predicate<? super Throwable> predicate)

Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.

Scheduler:

retry does not operate by default on a particular Scheduler.

Parameters:

predicate - the predicate called with the failure Throwable and should return true if a resubscription should happen

Returns:

the new Single instance

Throws:

NullPointerException - if predicate is null

Since:

2.0

retryUntil

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> retryUntil(@NonNull BooleanSupplier stop)

Retries until the given stop function returns true.

Scheduler:

retryUntil does not operate by default on a particular Scheduler.

Parameters:

stop - the function that should return true to stop retrying

Returns:

the new Single instance

Throws:

NullPointerException - if stop is null

Since:

3.0.0

retryWhen

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Single<T> retryWhen(@NonNull Function<? super Flowable<Throwable>,? extends Publisher<?>> handler)

Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.

If the Publisher signals an onComplete, the resulting Single will signal a NoSuchElementException.

Note that the inner Publisher returned by the handler function should signal either onNext, onError or onComplete in response to the received Throwable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signaling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this inner Publisher signals onError or onComplete while the upstream is active, the sequence is terminated with the same signal immediately.

The following example demonstrates how to retry an asynchronous source with a delay:

 Single.timer(1, TimeUnit.SECONDS)
     .doOnSubscribe(s -> System.out.println("subscribing"))
     .map(v -> { throw new RuntimeException(); })
     .retryWhen(errors -> {
         AtomicInteger counter = new AtomicInteger();
         return errors
                   .takeWhile(e -> counter.getAndIncrement() != 3)
                   .flatMap(e -> {
                       System.out.println("delay retry by " + counter.get() + " second(s)");
                       return Flowable.timer(counter.get(), TimeUnit.SECONDS);
                   });
     })
     .blockingGet();
 

Scheduler:

retryWhen does not operate by default on a particular Scheduler.

Parameters:

handler - the function that receives a Flowable of the error the Single emits and should return a Publisher that should signal a normal value (in response to the throwable the Flowable emits) to trigger a resubscription or signal an error to be the output of the resulting Single

Returns:

the new Single instance

Throws:

NullPointerException - if handler is null

safeSubscribe

@SchedulerSupport(value="none")
public final void safeSubscribe(@NonNull SingleObserver<? super T> observer)

Wraps the given SingleObserver, catches any RuntimeExceptions thrown by its SingleObserver.onSubscribe(Disposable), SingleObserver.onSuccess(Object) or SingleObserver.onError(Throwable) methods* and routes those to the global error handler via RxJavaPlugins.onError(Throwable).

By default, the Single protocol forbids the onXXX methods to throw, but some SingleObserver implementation may do it anyway, causing undefined behavior in the upstream. This method and the underlying safe wrapper ensures such misbehaving consumers don't disrupt the protocol.

Scheduler:

safeSubscribe does not operate by default on a particular Scheduler.

Parameters:

observer - the potentially misbehaving SingleObserver

Throws:

NullPointerException - if observer is null

Since:

3.0.0

See Also:

subscribe(Consumer,Consumer)

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public final @NonNull Flowable<T> startWith(@NonNull CompletableSource other)

Returns a Flowable which first runs the other CompletableSource then the current Single if the other completed normally.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other CompletableSource to run first

Returns:

the new Flowable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public final @NonNull Flowable<T> startWith(@NonNull SingleSource<T> other)

Returns a Flowable which first runs the other SingleSource then the current Single if the other succeeded normally.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other SingleSource to run first

Returns:

the new Flowable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public final @NonNull Flowable<T> startWith(@NonNull MaybeSource<T> other)

Returns a Flowable which first runs the other MaybeSource then the current Single if the other succeeded or completed normally.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other MaybeSource to run first

Returns:

the new Flowable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Observable<T> startWith(@NonNull ObservableSource<T> other)

Returns an Observable which first delivers the events of the other ObservableSource then runs the current Single.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other ObservableSource to run first

Returns:

the new Observable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

startWith

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final @NonNull Flowable<T> startWith(@NonNull Publisher<T> other)

Returns a Flowable which first delivers the events of the other Publisher then runs the current Single.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer and expects the other Publisher to honor it as well.

Scheduler:

startWith does not operate by default on a particular Scheduler.

Parameters:

other - the other Publisher to run first

Returns:

the new Flowable instance

Throws:

NullPointerException - if other is null

Since:

3.0.0

subscribe

@SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe()

Subscribes to a Single but ignore its emission or notification.

If the Single emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError(Throwable) handler.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Returns:

the new Disposable instance that can be used for disposing the subscription at any time

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, DisposableContainer)

subscribe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Disposable subscribe(@NonNull BiConsumer<? super T,? super Throwable> onCallback)

Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onCallback - the callback that receives either the success value or the failure Throwable (whichever is not null)

Returns:

the new Disposable instance that can be used for disposing the subscription at any time

Throws:

NullPointerException - if onCallback is null

See Also:

subscribe(Consumer, Consumer, DisposableContainer), ReactiveX operators documentation: Subscribe

subscribe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onSuccess)

Subscribes to a Single and provides a callback to handle the item it emits.

If the Single emits an error, it is wrapped into an OnErrorNotImplementedException and routed to the RxJavaPlugins.onError(Throwable) handler.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onSuccess - the Consumer<T> you have designed to accept the emission from the Single

Returns:

the new Disposable instance that can be used for disposing the subscription at any time

Throws:

NullPointerException - if onSuccess is null

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, DisposableContainer)

subscribe

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onSuccess,
        @NonNull Consumer<? super Throwable> onError)

Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onSuccess - the Consumer<T> you have designed to accept the emission from the Single

onError - the Consumer<Throwable> you have designed to accept any error notification from the Single

Returns:

the new Disposable instance that can be used for disposing the subscription at any time

Throws:

NullPointerException - if onSuccess or onError is null

See Also:

ReactiveX operators documentation: Subscribe, subscribe(Consumer, Consumer, DisposableContainer)

subscribe

@SchedulerSupport(value="none")
 @NonNull
public final @NonNull Disposable subscribe(@NonNull Consumer<? super T> onSuccess,
        @NonNull Consumer<? super Throwable> onError,
        @NonNull DisposableContainer container)

Wraps the given onXXX callbacks into a Disposable SingleObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the SingleObserver is removed from the given container.

The SingleObserver will be removed after the callback for the terminal event has been invoked.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

onSuccess - the callback for upstream items

onError - the callback for an upstream error if any

container - the DisposableContainer (such as CompositeDisposable) to add and remove the created Disposable SingleObserver

Returns:

the Disposable that allows disposing the particular subscription.

Throws:

NullPointerException - if onSuccess, onError or container is null

Since:

3.1.0

subscribe

@SchedulerSupport(value="none")
public final void subscribe(@NonNull SingleObserver<? super T> observer)

Description copied from interface: SingleSource

Subscribes the given SingleObserver to this SingleSource instance.

Specified by:

subscribe in interface SingleSource<T>

Parameters:

observer - the SingleObserver, not null

subscribeActual

protected abstract void subscribeActual(@NonNull SingleObserver<? super T> observer)

Implement this method in subclasses to handle the incoming SingleObservers.

There is no need to call any of the plugin hooks on the current Single instance or the SingleObserver; all hooks and basic safeguards have been applied by subscribe(SingleObserver) before this method gets called.

Parameters:

observer - the SingleObserver to handle, not null

subscribeWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <E extends SingleObserver<? super T>> E subscribeWith(E observer)

Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.

Usage example:

 Single<Integer> source = Single.just(1);
 CompositeDisposable composite = new CompositeDisposable();

 DisposableSingleObserver<Integer> ds = new DisposableSingleObserver<>() {
     // ...
 };

 composite.add(source.subscribeWith(ds));
 

Scheduler:

subscribeWith does not operate by default on a particular Scheduler.

Type Parameters:

E - the type of the SingleObserver to use and return

Parameters:

observer - the SingleObserver (subclass) to use and return, not null

Returns:

the input observer

Throws:

NullPointerException - if observer is null

Since:

2.0

subscribeOn

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<T> subscribeOn(@NonNull Scheduler scheduler)

Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.

Scheduler:

You specify which Scheduler this operator will use.

Parameters:

scheduler - the Scheduler to perform subscription actions on

Returns:

the new Single instance

Throws:

NullPointerException - if scheduler is null

See Also:

ReactiveX operators documentation: SubscribeOn, RxJava Threading Examples, observeOn(io.reactivex.rxjava3.core.Scheduler)

timeInterval

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final @NonNull Single<Timed<T>> timeInterval()

Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

If the current Single fails, the resulting Single will pass along the signal to the downstream. To measure the time to error, use materialize() and apply timeInterval().

Scheduler:

timeInterval uses the computation Scheduler for determining the current time upon subscription and upon receiving the success item from the current Single.

Returns:

the new Single instance

Since:

3.0.0

timeInterval

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<Timed<T>> timeInterval(@NonNull Scheduler scheduler)

Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

If the current Single fails, the resulting Single will pass along the signal to the downstream. To measure the time to error, use materialize() and apply timeInterval(Scheduler).

Scheduler:

timeInterval uses the provided Scheduler for determining the current time upon subscription and upon receiving the success item from the current Single.

Parameters:

scheduler - the Scheduler used for providing the current time

Returns:

the new Single instance

Throws:

NullPointerException - if scheduler is null

Since:

3.0.0

timeInterval

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final @NonNull Single<Timed<T>> timeInterval(@NonNull TimeUnit unit)

Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

If the current Single fails, the resulting Single will pass along the signals to the downstream. To measure the time to error, use materialize() and apply timeInterval(TimeUnit, Scheduler).

Scheduler:

timeInterval uses the computation Scheduler for determining the current time upon subscription and upon receiving the success item from the current Single.

Parameters:

unit - the time unit for measurement

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

3.0.0

timeInterval

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<Timed<T>> timeInterval(@NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

If the current Single is empty or fails, the resulting Single will pass along the signals to the downstream. To measure the time to termination, use materialize() and apply timeInterval(TimeUnit, Scheduler).

Scheduler:

timeInterval uses the provided Scheduler for determining the current time upon subscription and upon receiving the success item from the current Single.

Parameters:

unit - the time unit for measurement

scheduler - the Scheduler used for providing the current time

Returns:

the new Single instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

3.0.0

timestamp

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final @NonNull Single<Timed<T>> timestamp()

Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.

If the current Single is empty or fails, the resulting Single will pass along the signals to the downstream. To get the timestamp of the error, use materialize() and apply timestamp().

Scheduler:

timestamp uses the computation Scheduler for determining the current time upon receiving the success item from the current Single.

Returns:

the new Single instance

Since:

3.0.0

timestamp

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<Timed<T>> timestamp(@NonNull Scheduler scheduler)

Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.

If the current Single is empty or fails, the resulting Single will pass along the signals to the downstream. To get the timestamp of the error, use materialize() and apply timestamp(Scheduler).

Scheduler:

timestamp uses the provided Scheduler for determining the current time upon receiving the success item from the current Single.

Parameters:

scheduler - the Scheduler used for providing the current time

Returns:

the new Single instance

Throws:

NullPointerException - if scheduler is null

Since:

3.0.0

timestamp

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final @NonNull Single<Timed<T>> timestamp(@NonNull TimeUnit unit)

Combines the success value from the current Single with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.

If the current Single is empty or fails, the resulting Single will pass along the signals to the downstream. To get the timestamp of the error, use materialize() and apply timestamp(TimeUnit).

Scheduler:

timestamp uses the computation Scheduler, for determining the current time upon receiving the success item from the current Single.

Parameters:

unit - the time unit for measurement

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

3.0.0

timestamp

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<Timed<T>> timestamp(@NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Combines the success value from the current Single with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.

If the current Single is empty or fails, the resulting Single will pass along the signals to the downstream. To get the timestamp of the error, use materialize() and apply timestamp(TimeUnit, Scheduler).

Scheduler:

timestamp uses the provided Scheduler, which is used for determining the current time upon receiving the success item from the current Single.

Parameters:

unit - the time unit for measurement

scheduler - the Scheduler used for providing the current time

Returns:

the new Single instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

3.0.0

takeUntil

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final @NonNull Single<T> takeUntil(@NonNull CompletableSource other)

Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates. Upon termination of other, this will emit a CancellationException rather than go to SingleObserver.onSuccess(Object).

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Parameters:

other - the CompletableSource whose termination will cause takeUntil to emit the item from the current Single

Returns:

the new Single that emits the item emitted by the current Single until such time as other terminates.

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: TakeUntil

takeUntil

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <E> @NonNull Single<T> takeUntil(@NonNull Publisher<E> other)

Returns a Single that emits the item emitted by the current Single until a Publisher emits an item or completes. Upon emission of an item from other, this will emit a CancellationException rather than go to SingleObserver.onSuccess(Object).

Backpressure:

The other publisher is consumed in an unbounded fashion but will be cancelled after the first item it produced.

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Type Parameters:

E - the type of items emitted by other

Parameters:

other - the Publisher whose first emitted item or completion will cause takeUntil to emit CancellationException if the current Single hasn't completed till then

Returns:

the new Single that emits the item emitted by the current Single until such time as other emits its first item

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: TakeUntil

takeUntil

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
public final <E> @NonNull Single<T> takeUntil(@NonNull SingleSource<? extends E> other)

Returns a Single that emits the item emitted by the current Single until a second Single emits an item. Upon emission of an item from other, this will emit a CancellationException rather than go to SingleObserver.onSuccess(Object).

Scheduler:

takeUntil does not operate by default on a particular Scheduler.

Type Parameters:

E - the type of item emitted by other

Parameters:

other - the Single whose emitted item will cause takeUntil to emit CancellationException if the current Single hasn't completed till then

Returns:

the new Single that emits the item emitted by the current Single until such time as other emits its item

Throws:

NullPointerException - if other is null

See Also:

ReactiveX operators documentation: TakeUntil

timeout

@CheckReturnValue
 @SchedulerSupport(value="io.reactivex:computation")
 @NonNull
public final @NonNull Single<T> timeout(long timeout,
        @NonNull TimeUnit unit)

Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.

Scheduler:

timeout signals the TimeoutException on the computation Scheduler.

Parameters:

timeout - the timeout amount

unit - the time unit

Returns:

the new Single instance

Throws:

NullPointerException - if unit is null

Since:

2.0

timeout

@CheckReturnValue
 @SchedulerSupport(value="custom")
 @NonNull
public final @NonNull Single<T> timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler)

Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.

Scheduler:

timeout signals the TimeoutException on the Scheduler you specify.

Parameters:

timeout - the timeout amount

unit - the time unit

scheduler - the target Scheduler where the timeout is awaited and the TimeoutException signaled

Returns:

the new Single instance

Throws:

NullPointerException - if unit or scheduler is null

Since:

2.0

timeout

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<T> timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull Scheduler scheduler,
        @NonNull SingleSource<? extends 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.

Scheduler:

timeout subscribes to the other SingleSource on the Scheduler you specify.

Parameters:

timeout - the timeout amount

unit - the time unit

scheduler - the Scheduler where the timeout is awaited and the subscription to other happens

fallback - the other SingleSource that gets subscribed to if the current Single times out

Returns:

the new Single instance

Throws:

NullPointerException - if unit, scheduler or fallback is null

Since:

2.0

timeout

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="io.reactivex:computation")
public final @NonNull Single<T> timeout(long timeout,
        @NonNull TimeUnit unit,
        @NonNull SingleSource<? extends 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.

Scheduler:

timeout subscribes to the other SingleSource on the computation Scheduler.

Parameters:

timeout - the timeout amount

unit - the time unit

fallback - the other SingleSource that gets subscribed to if the current Single times out

Returns:

the new Single instance

Throws:

NullPointerException - if fallback or unit is null

Since:

2.0

to

@CheckReturnValue
 @SchedulerSupport(value="none")
public final <R> R to(@NonNull SingleConverter<T,? extends R> converter)

Calls the specified converter function during assembly time and returns its resulting value.

This allows fluent conversion to any other type.

Scheduler:

to does not operate by default on a particular Scheduler.

History: 2.1.7 - experimental

Type Parameters:

R - the resulting object type

Parameters:

converter - the function that receives the current Single instance and returns a value

Returns:

the converted value

Throws:

NullPointerException - if converter is null

Since:

2.2

ignoreElement

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Completable ignoreElement()

Returns a Completable that ignores the success value of this Single and signals onComplete instead.

Scheduler:

ignoreElement does not operate by default on a particular Scheduler.

Returns:

the new Completable instance

Since:

2.1.13

toFlowable

@BackpressureSupport(value=FULL)
 @CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Flowable<T> toFlowable()

Converts this Single into a Flowable.

Backpressure:

The returned Flowable honors the backpressure of the downstream consumer.

Scheduler:

toFlowable does not operate by default on a particular Scheduler.

Returns:

the new Flowable instance

toFuture

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Future<T> toFuture()

Returns a Future representing the single value emitted by this Single.

Cancelling the Future will cancel the subscription to the current Single.

Scheduler:

toFuture does not operate by default on a particular Scheduler.

Returns:

the new Future instance

See Also:

ReactiveX documentation: To

toMaybe

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Maybe<T> toMaybe()

Converts this Single into a Maybe.

Scheduler:

toMaybe does not operate by default on a particular Scheduler.

Returns:

the new Maybe instance

toObservable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull Observable<T> toObservable()

Converts this Single into an Observable.

Scheduler:

toObservable does not operate by default on a particular Scheduler.

Returns:

the new Observable instance

unsubscribeOn

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="custom")
public final @NonNull Single<T> unsubscribeOn(@NonNull Scheduler scheduler)

Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified Scheduler.

Scheduler:

unsubscribeOn calls dispose() of the upstream on the Scheduler you specify.

History: 2.0.9 - experimental

Parameters:

scheduler - the target scheduler where to execute the disposal

Returns:

the new Single instance

Throws:

NullPointerException - if scheduler is null

Since:

2.2

zipWith

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <U,R> @NonNull Single<R> zipWith(@NonNull SingleSource<U> other,
        @NonNull BiFunction<? super T,? super U,? extends 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.

Scheduler:

zipWith does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of items emitted by the other Single

R - the type of items emitted by the resulting Single

Parameters:

other - the other SingleSource

zipper - a function that combines the pairs of items from the two SingleSources to generate the items to be emitted by the resulting Single

Returns:

the new Single that pairs up values from the current Single and the other SingleSource and emits the results of zipFunction applied to these pairs

Throws:

NullPointerException - if other or zipper is null

See Also:

ReactiveX operators documentation: Zip

test

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull TestObserver<T> test()

Creates a TestObserver and subscribes it to this Single.

Scheduler:

test does not operate by default on a particular Scheduler.

Returns:

the new TestObserver instance

Since:

2.0

test

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull TestObserver<T> test(boolean dispose)

Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.

Scheduler:

test does not operate by default on a particular Scheduler.

Parameters:

dispose - if true, the TestObserver will be cancelled before subscribing to this Single.

Returns:

the new TestObserver instance

Since:

2.0

fromCompletionStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public static <T> @NonNull Single<T> fromCompletionStage(@NonNull CompletionStage<T> stage)

Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.

Note that the operator takes an already instantiated, running or terminated CompletionStage. If the CompletionStage is to be created per consumer upon subscription, use defer(Supplier) around fromCompletionStage:

 Single.defer(() -> Single.fromCompletionStage(createCompletionStage()));
 

If the CompletionStage completes with null, the resulting Single is terminated with a NullPointerException.

Canceling the flow can't cancel the execution of the CompletionStage because CompletionStage itself doesn't support cancellation. Instead, the operator detaches from the CompletionStage.

Scheduler:

fromCompletionStage does not operate by default on a particular Scheduler.

Type Parameters:

T - the element type of the CompletionStage

Parameters:

stage - the CompletionStage to convert to Single and signal its success value or error

Returns:

the new Single instance

Throws:

NullPointerException - if stage is null

Since:

3.0.0

mapOptional

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Maybe<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)

Maps the upstream success value into an Optional and emits the contained item if not empty as a Maybe.

Scheduler:

mapOptional does not operate by default on a particular Scheduler.

Type Parameters:

R - the non-null output type

Parameters:

mapper - the function that receives the upstream success item and should return a non-empty Optional to emit as the success output or an empty Optional to complete the Maybe

Returns:

the new Maybe instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

map(Function), filter(Predicate)

toCompletionStage

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final @NonNull CompletionStage<T> toCompletionStage()

Signals the upstream success item (or error) via a CompletionStage.

The upstream can be canceled by converting the resulting CompletionStage into CompletableFuture via CompletionStage.toCompletableFuture() and calling CompletableFuture.cancel(boolean) on it. The upstream will be also cancelled if the resulting CompletionStage is converted to and completed manually by CompletableFuture.complete(Object) or CompletableFuture.completeExceptionally(Throwable).

Scheduler:

toCompletionStage does not operate by default on a particular Scheduler.

Returns:

the new CompletionStage instance

Since:

3.0.0

flattenStreamAsFlowable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
 @NonNull
public final <R> @NonNull Flowable<R> flattenStreamAsFlowable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)

Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flattenAsFlowable(Function):

 source.flattenAsFlowable(item -> createStream(item)::iterator);
 

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 source.flattenStreamAsFlowable(item -> IntStream.rangeClosed(1, 10).boxed());
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Backpressure:

The operator honors backpressure from downstream and iterates the given Stream on demand (i.e., when requested).

Scheduler:

flattenStreamAsFlowable does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the Stream and the output Flowable

Parameters:

mapper - the function that receives the upstream success item and should return a Stream of values to emit.

Returns:

the new Flowable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

flattenAsFlowable(Function), flattenStreamAsObservable(Function)

flattenStreamAsObservable

@CheckReturnValue
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull Observable<R> flattenStreamAsObservable(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)

Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flattenAsObservable(Function):

 source.flattenAsObservable(item -> createStream(item)::iterator);
 

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 source.flattenStreamAsObservable(item -> IntStream.rangeClosed(1, 10).boxed());
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Scheduler:

flattenStreamAsObservable does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the Stream and the output Observable

Parameters:

mapper - the function that receives the upstream success item and should return a Stream of values to emit.

Returns:

the new Observable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

flattenAsObservable(Function), flattenStreamAsFlowable(Function)