Class SingleSubject<T>

java.lang.Object

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

io.reactivex.rxjava4.subjects.SingleSubject<T>

Type Parameters:

T - the value type received and emitted

All Implemented Interfaces:

SingleObserver<T>, SingleSource<T>

public final class SingleSubject<T>
extends Single<T>
implements SingleObserver<T>

Represents a hot Single-like source and consumer of events similar to Subjects.

This subject does not have a public constructor by design; a new non-terminated instance of this SingleSubject can be created via the create() method.

Since the SingleSubject is conceptionally derived from the Processor type in the Reactive Streams specification, nulls are not allowed (Rule 2.13) as parameters to onSuccess(Object) and onError(Throwable). Such calls will result in a NullPointerException being thrown and the subject's state is not changed.

Since a SingleSubject is a Single, calling onSuccess or onError will move this SingleSubject into its terminal state atomically.

All methods are thread safe. Calling onSuccess(Object) multiple times has no effect. Calling onError(Throwable) multiple times relays the Throwable to the RxJavaPlugins.onError(Throwable) global error handler.

Even though SingleSubject implements the SingleObserver interface, calling onSubscribe is not required (Rule 2.12) if the subject is used as a standalone source. However, calling onSubscribe after the SingleSubject reached its terminal state will result in the given Disposable being disposed immediately.

This SingleSubject supports the standard state-peeking methods hasThrowable(), getThrowable() and hasObservers() as well as means to read any success item in a non-blocking and thread-safe manner via hasValue() and getValue().

The SingleSubject does not support clearing its cached onSuccess value.

Scheduler:

SingleSubject does not operate by default on a particular Scheduler and the SingleObservers get notified on the thread where the terminating onSuccess or onError methods were invoked.

Error handling:

When the onError(Throwable) is called, the SingleSubject enters into a terminal state and emits the same Throwable instance to the last set of SingleObservers. During this emission, if one or more SingleObservers dispose their respective Disposables, the Throwable is delivered to the global error handler via RxJavaPlugins.onError(Throwable) (multiple times if multiple SingleObservers cancel at once). If there were no SingleObservers subscribed to this SingleSubject when the onError() was called, the global error handler is not invoked.

Example usage:

SingleSubject<Integer> subject1 = SingleSubject.create();

TestObserver<Integer> to1 = subject1.test();

// SingleSubjects are empty by default
to1.assertEmpty();

subject1.onSuccess(1);

// onSuccess is a terminal event with SingleSubjects
// TestObserver converts onSuccess into onNext + onComplete
to1.assertResult(1);

TestObserver<Integer> to2 = subject1.test();

// late Observers receive the terminal signal (onSuccess) too
to2.assertResult(1);

History: 2.0.5 - experimental

Since:

2.1

Method Summary

Modifier and Type	Method	Description
static <T> @NonNull SingleSubject<T>	create()	Creates a fresh SingleSubject.
@Nullable Throwable	getThrowable()	Returns the terminal error if this SingleSubject has been terminated with an error, null otherwise.
T	getValue()	Returns the success value if this SingleSubject was terminated with a success value.
boolean	hasObservers()	Returns true if this SingleSubject has observers.
boolean	hasThrowable()	Returns true if this SingleSubject has been terminated with an error.
boolean	hasValue()	Returns true if this SingleSubject was terminated with a success value.
void	onError(@NonNull Throwable e)	Notifies the SingleObserver that the Single has experienced an error condition.
void	onSubscribe(@NonNull Disposable d)	Provides the SingleObserver with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
void	onSuccess(T value)	Notifies the SingleObserver with a single item and that the Single has finished sending push-based notifications.
protected void	subscribeActual(@NonNull SingleObserver<? super T> observer)	Implement this method in subclasses to handle the incoming SingleObservers.

Methods inherited from class Single

amb, ambArray, ambWith, blockingGet, blockingSubscribe, blockingSubscribe, blockingSubscribe, blockingSubscribe, cache, cast, compose, concat, concat, concat, concat, concat, concat, concat, concatArray, concatArrayDelayError, concatArrayEager, concatArrayEagerDelayError, concatDelayError, concatDelayError, concatDelayError, concatEager, concatEager, concatEager, concatEager, concatEagerDelayError, concatEagerDelayError, concatEagerDelayError, concatEagerDelayError, concatMap, concatMapCompletable, concatMapMaybe, concatWith, contains, contains, create, defer, delay, delay, delay, delay, delaySubscription, delaySubscription, delaySubscription, delaySubscription, delaySubscription, delaySubscription, dematerialize, doAfterSuccess, doAfterTerminate, doFinally, doOnDispose, doOnError, doOnEvent, doOnLifecycle, doOnSubscribe, doOnSuccess, doOnTerminate, error, error, filter, flatMap, flatMap, flatMap, flatMapCompletable, flatMapMaybe, flatMapObservable, flatMapPublisher, flattenAsFlowable, flattenAsObservable, flattenStreamAsFlowable, flattenStreamAsObservable, fromCallable, fromCompletionStage, fromFuture, fromFuture, fromMaybe, fromMaybe, fromObservable, fromPublisher, fromSupplier, hide, ignoreElement, just, lift, map, mapOptional, materialize, merge, merge, merge, merge, merge, merge, mergeArray, mergeArrayDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeDelayError, mergeWith, never, observeOn, ofType, onErrorComplete, onErrorComplete, onErrorResumeNext, onErrorResumeWith, onErrorReturn, onErrorReturnItem, onTerminateDetach, repeat, repeat, repeatUntil, repeatWhen, retry, retry, retry, retry, retry, retryUntil, retryWhen, safeSubscribe, sequenceEqual, startWith, startWith, startWith, startWith, startWith, subscribe, subscribe, subscribe, subscribe, subscribe, subscribe, subscribeOn, subscribeWith, switchOnNext, switchOnNextDelayError, takeUntil, takeUntil, takeUntil, test, test, timeInterval, timeInterval, timeInterval, timeInterval, timeout, timeout, timeout, timeout, timer, timer, timestamp, timestamp, timestamp, timestamp, to, toCompletionStage, toFlowable, toFuture, toMaybe, toObservable, unsafeCreate, unsubscribeOn, using, using, wrap, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipArray, zipWith

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Single<T>	amb(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
static <@NonNull T> @NonNull Single<T>	ambArray(@NonNull SingleSource<? extends @NonNull T>... sources)	Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).
final @NonNull Single<T>	ambWith(@NonNull SingleSource<? extends T> other)	Signals the event of this or the other SingleSource whichever signals first.
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).
final void	blockingSubscribe()	Subscribes to the current Single and blocks the current thread until it terminates.
final void	blockingSubscribe(@NonNull SingleObserver<? super T> observer)	Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread.
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.
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.
final @NonNull Single<T>	cache()	Stores the success value or exception from the current Single and replays it to late SingleObservers.
final <@NonNull U> @NonNull Single<U>	cast(@NonNull Class<? extends @NonNull U> clazz)	Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.
final <@NonNull R> @NonNull Single<R>	compose(@NonNull SingleTransformer<? super T, ? extends @NonNull R> transformer)	Transform a Single by applying a particular SingleTransformer function to it.
static <@NonNull T> @NonNull Observable<T>	concat(@NonNull ObservableSource<? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an ObservableSource sequence.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four SingleSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Flow.Publisher sequence.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Flow.Publisher sequence and prefetched by the specified amount.
static <@NonNull T> @NonNull Flowable<T>	concatArray(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <@NonNull T> @NonNull Flowable<T>	concatArrayDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.
static <@NonNull T> @NonNull Flowable<T>	concatArrayEager(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	concatArrayEagerDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Concatenates a sequence of SingleSource eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	concatDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of SingleSources into a single sequence by subscribing to each SingleSource, one after the other, one at a time and delays any errors till the all inner SingleSources terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatDelayError(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates the Flow.Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatDelayError(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int prefetch)	Concatenates the Flow.Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values and runs a limited number of the inner sources at once.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates a Flow.Publisher sequence of SingleSources eagerly into a single stream of values.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Flow.Publisher sequence of SingleSources eagerly into a single stream of values and runs a limited number of those inner SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Concatenates a Flow.Publisher sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Flow.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.
final <@NonNull R> @NonNull Single<R>	concatMap(@NonNull Function<? super T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
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.
final <@NonNull R> @NonNull Maybe<R>	concatMapMaybe(@NonNull Function<? super T, ? extends MaybeSource<? extends @NonNull 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.
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.
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.
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.
static <@NonNull T> @NonNull Single<T>	create(@NonNull SingleOnSubscribe<@NonNull T> source)	Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.
static <@NonNull T> @NonNull Single<T>	defer(@NonNull Supplier<? extends @NonNull SingleSource<? extends @NonNull T>> supplier)	Calls a Supplier for each individual SingleObserver to return the actual SingleSource to be subscribed to.
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.
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.
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.
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.
final @NonNull Single<T>	delaySubscription(long time, @NonNull TimeUnit unit)	Delays the actual subscription to the current Single until the given time delay elapsed.
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.
final @NonNull Single<T>	delaySubscription(@NonNull CompletableSource subscriptionIndicator)	Delays the actual subscription to the current Single until the given other CompletableSource completes.
final <@NonNull U> @NonNull Single<T>	delaySubscription(@NonNull ObservableSource<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.
final <@NonNull U> @NonNull Single<T>	delaySubscription(@NonNull SingleSource<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other SingleSource signals success.
final <@NonNull U> @NonNull Single<T>	delaySubscription(@NonNull Flow.Publisher<@NonNull U> subscriptionIndicator)	Delays the actual subscription to the current Single until the given other Flow.Publisher signals its first value or completes.
final <@NonNull R> @NonNull Maybe<R>	dematerialize(@NonNull Function<? super T, @NonNull Notification<@NonNull R>> selector)	Maps the Notification success value of the current Single back into normal onSuccess, onError or onComplete signals as a Maybe source.
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.
final @NonNull Single<T>	doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called after this Single invokes either onSuccess or onError.
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.
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.
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.
final @NonNull Single<T>	doOnEvent(@NonNull BiConsumer<@Nullable ? super T, @Nullable ? 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.
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).
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.
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.
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.
static <@NonNull T> @NonNull Single<T>	error(@NonNull Supplier<? extends @NonNull Throwable> supplier)	Signals a Throwable returned by the callback function for each individual SingleObserver.
static <@NonNull T> @NonNull Single<T>	error(@NonNull Throwable throwable)	Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.
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.
final <@NonNull R> @NonNull Single<R>	flatMap(@NonNull Function<? super T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.
final <@NonNull R> @NonNull Single<R>	flatMap(@NonNull Function<? super T, ? extends SingleSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends SingleSource<? extends @NonNull R>> onErrorMapper)	Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.
final <@NonNull U, @NonNull R> @NonNull Single<R>	flatMap(@NonNull Function<? super T, ? extends SingleSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns a Single that emits the results of a specified function to the pair of values emitted by the current Single and a specified mapped SingleSource.
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.
final <@NonNull R> @NonNull Maybe<R>	flatMapMaybe(@NonNull Function<? super T, ? extends MaybeSource<? extends @NonNull 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.
final <@NonNull R> @NonNull Observable<R>	flatMapObservable(@NonNull Function<? super T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that is based on applying a specified function to the item emitted by the current Single, where that function returns an ObservableSource.
final <@NonNull R> @NonNull Flowable<R>	flatMapPublisher(@NonNull Function<? super T, @NonNull ? extends Flow.Publisher<? extends @NonNull 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 Flow.Publisher.
final <@NonNull U> @NonNull Flowable<U>	flattenAsFlowable(@NonNull Function<? super T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Single into an Iterable and emits its items as a Flowable sequence.
final <@NonNull U> @NonNull Observable<U>	flattenAsObservable(@NonNull Function<@NonNull ? super T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Single into an Iterable and emits its items as an Observable sequence.
final <@NonNull R> @NonNull Flowable<R>	flattenStreamAsFlowable(@NonNull Function<? super T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
final <@NonNull R> @NonNull Observable<R>	flattenStreamAsObservable(@NonNull Function<? super T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.
static <@NonNull T> @NonNull Single<T>	fromCallable(@NonNull Callable<? extends @NonNull T> callable)	Returns a Single that invokes the given Callable for each incoming SingleObserver and emits its value or exception to them.
static <@NonNull T> @NonNull Single<@NonNull T>	fromCompletionStage(@NonNull CompletionStage<@NonNull T> stage)	Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <@NonNull T> @NonNull Single<T>	fromFuture(@NonNull Future<? extends @NonNull T> future)	Converts a Future into a Single and awaits its outcome in a blocking fashion.
static <@NonNull T> @NonNull Single<T>	fromFuture(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit)	Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.
static <@NonNull T> @NonNull Single<T>	fromMaybe(@NonNull MaybeSource<@NonNull 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 <@NonNull T> @NonNull Single<T>	fromMaybe(@NonNull MaybeSource<@NonNull 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.
static <@NonNull T> @NonNull Single<T>	fromObservable(@NonNull ObservableSource<? extends @NonNull T> observable)	Wraps a specific ObservableSource into a Single and signals its single element or error.
static <@NonNull T> @NonNull Single<T>	fromPublisher(@NonNull Flow.Publisher<? extends @NonNull T> publisher)	Wraps a specific Flow.Publisher into a Single and signals its single element or error.
static <@NonNull T> @NonNull Single<T>	fromSupplier(@NonNull Supplier<? extends @NonNull T> supplier)	Returns a Single that invokes passed supplier and emits its result for each individual SingleObserver that subscribes.
final @NonNull Single<T>	hide()	Hides the identity of the current Single, including the Disposable that is sent to the downstream via onSubscribe().
final @NonNull Completable	ignoreElement()	Returns a Completable that ignores the success value of this Single and signals onComplete instead.
static <@NonNull T> @NonNull Single<T>	just(@NonNull T item)	Returns a Single that emits a specified item.
final <@NonNull R> @NonNull Single<R>	lift(@NonNull SingleOperator<? extends @NonNull 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.
final <@NonNull R> @NonNull Single<R>	map(@NonNull Function<? super T, ? extends @NonNull 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.
final <@NonNull R> @NonNull Maybe<R>	mapOptional(@NonNull Function<? super T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps the upstream success value into an Optional and emits the contained item if not empty as a Maybe.
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.
static <@NonNull T> @NonNull Single<T>	merge(@NonNull SingleSource<? extends SingleSource<? extends @NonNull T>> source)	Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item emitted by the nested SingleSource, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Flattens two SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Flattens three SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Flattens four SingleSources into one Flowable sequence, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges a sequence of SingleSource instances emitted by a Flow.Publisher into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	mergeArray(SingleSource<? extends @NonNull T>... sources)	Merges an array of SingleSource instances into a single Flowable sequence, running all SingleSources at once.
static <@NonNull T> @NonNull Flowable<T>	mergeArrayDelayError(@NonNull SingleSource<? extends @NonNull T>... sources)	Flattens an array of SingleSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source SingleSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2, @NonNull SingleSource<? extends @NonNull T> source3, @NonNull SingleSource<? extends @NonNull T> source4)	Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of SingleSource instances into one Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Merges a sequence of SingleSource instances emitted by a Flow.Publisher into a Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
final @NonNull Flowable<T>	mergeWith(@NonNull SingleSource<? extends T> other)	Flattens this Single and another SingleSource into one Flowable, without any transformation.
static <@NonNull T> @NonNull Single<T>	never()	Returns a singleton instance of a never-signaling Single (only calls onSubscribe).
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.
final <@NonNull U> @NonNull Maybe<U>	ofType(@NonNull Class<@NonNull U> clazz)	Filters the items emitted by the current Single, only emitting its success value if that is an instance of the supplied Class.
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.
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.
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.
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.
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.
final @NonNull Single<T>	onErrorReturnItem(T item)	Signals the specified value as success in case the current Single signals an error.
final @NonNull Single<T>	onTerminateDetach()	Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().
final @NonNull Flowable<T>	repeat()	Repeatedly re-subscribes to the current Single and emits each success value as a Flowable sequence.
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.
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.
final @NonNull Flowable<T>	repeatWhen(@NonNull Function<? super Flowable<Object>, @NonNull ? extends Flow.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if the Flow.Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.
final @NonNull Single<T>	retry()	Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
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.
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.
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.
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.
final @NonNull Single<T>	retryUntil(@NonNull BooleanSupplier stop)	Retries until the given stop function returns true.
final @NonNull Single<T>	retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends Flow.Publisher<@NonNull ?>> handler)	Re-subscribes to the current Single if and when the Flow.Publisher returned by the handler function signals a value.
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).
static <@NonNull T> @NonNull Single<Boolean>	sequenceEqual(@NonNull SingleSource<? extends @NonNull T> source1, @NonNull SingleSource<? extends @NonNull T> source2)	Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).
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.
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.
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.
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.
final @NonNull Flowable<T>	startWith(@NonNull Flow.Publisher<T> other)	Returns a Flowable which first delivers the events of the other Flow.Publisher then runs the current Single.
final @NonNull Disposable	subscribe()	Subscribes to a Single but ignore its emission or notification.
final void	subscribe(@NonNull SingleObserver<? super T> observer)	Subscribes the given SingleObserver to this SingleSource instance.
final @NonNull Disposable	subscribe(@NonNull BiConsumer<@Nullable ? super T, @Nullable ? super Throwable> onCallback)	Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.
final @NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess)	Subscribes to a Single and provides a callback to handle the item it emits.
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.
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.
final @NonNull Single<T>	subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.
final <@NonNull E extends SingleObserver<? super @NonNull T>> E	subscribeWith(@NonNull E observer)	Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.
static <@NonNull T> @NonNull Flowable<T>	switchOnNext(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Switches between SingleSources emitted by the source Flow.Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	switchOnNextDelayError(@NonNull Flow.Publisher<@NonNull ? extends SingleSource<? extends @NonNull T>> sources)	Switches between SingleSources emitted by the source Flow.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.
final @NonNull Single<T>	takeUntil(@NonNull CompletableSource other)	Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.
final <@NonNull E> @NonNull Single<T>	takeUntil(@NonNull SingleSource<? extends @NonNull E> other)	Returns a Single that emits the item emitted by the current Single until a second Single emits an item.
final <@NonNull E> @NonNull Single<T>	takeUntil(@NonNull Flow.Publisher<@NonNull E> other)	Returns a Single that emits the item emitted by the current Single until a Flow.Publisher emits an item or completes.
final @NonNull TestObserver<T>	test()	Creates a TestObserver and subscribes it to this Single.
final @NonNull TestObserver<T>	test(boolean dispose)	Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
final <R> R	to(@NonNull SingleConverter<T, ? extends R> converter)	Calls the specified converter function during assembly time and returns its resulting value.
final @NonNull CompletionStage<T>	toCompletionStage()	Signals the upstream success item (or error) via a CompletionStage.
final @NonNull Flowable<T>	toFlowable()	Converts this Single into a Flowable.
final @NonNull Future<T>	toFuture()	Returns a Future representing the single value emitted by this Single.
final @NonNull Maybe<T>	toMaybe()	Converts this Single into a Maybe.
final @NonNull Observable<T>	toObservable()	Converts this Single into an Observable.
static <@NonNull T> @NonNull Single<T>	unsafeCreate(@NonNull SingleSource<@NonNull T> onSubscribe)	Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.
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.
static <@NonNull T, @NonNull U> @NonNull Single<T>	using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U, ? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T, @NonNull U> @NonNull Single<T>	using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U, ? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup, boolean eager)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T> @NonNull Single<T>	wrap(@NonNull SingleSource<@NonNull T> source)	Wraps a SingleSource instance into a new Single instance if not already a Single instance.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull SingleSource<? extends @NonNull T8> source8, @NonNull SingleSource<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? super @NonNull T8, ? super @NonNull T9, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull SingleSource<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? super @NonNull T8, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull SingleSource<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull SingleSource<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull SingleSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull SingleSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull SingleSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other SingleSources.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Single<R>	zip(@NonNull SingleSource<? extends @NonNull T1> source1, @NonNull SingleSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper)	Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other SingleSources.
static <@NonNull T, @NonNull R> @NonNull Single<R>	zip(@NonNull Iterable<@NonNull ? extends SingleSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper)	Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to the downstream.
static <@NonNull T, @NonNull R> @NonNull Single<R>	zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull SingleSource<? extends @NonNull T>... sources)	Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.
final <@NonNull U, @NonNull R> @NonNull Single<R>	zipWith(@NonNull SingleSource<@NonNull U> other, @NonNull BiFunction<? super T, ? super @NonNull U, ? extends @NonNull R> zipper)	Returns a Single that emits the result of applying a specified function to the pair of items emitted by the current Single and another specified SingleSource.

Methods inherited from class Object

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

Method Details

create

@CheckReturnValue
@NonNull
public static <T> @NonNull SingleSubject<T> create()

Creates a fresh SingleSubject.

Type Parameters:

T - the value type received and emitted

Returns:

the new SingleSubject instance

onSubscribe

public void onSubscribe(@NonNull
 @NonNull Disposable d)

Description copied from interface: SingleObserver

Provides the SingleObserver with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.

Specified by:

onSubscribe in interface SingleObserver<T>

Parameters:

d - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection

onSuccess

public void onSuccess(@NonNull
 T value)

Description copied from interface: SingleObserver

Notifies the SingleObserver with a single item and that the Single has finished sending push-based notifications.

The Single will not call this method if it calls SingleObserver.onError(Throwable).

Specified by:

onSuccess in interface SingleObserver<T>

Parameters:

value - the item emitted by the Single

onError

public void onError(@NonNull
 @NonNull Throwable e)

Description copied from interface: SingleObserver

Notifies the SingleObserver that the Single has experienced an error condition.

If the Single calls this method, it will not thereafter call SingleObserver.onSuccess(T).

Specified by:

onError in interface SingleObserver<T>

Parameters:

e - the exception encountered by the Single

subscribeActual

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

Description copied from class: Single

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 Single.subscribe(SingleObserver) before this method gets called.

Specified by:

subscribeActual in class Single<T>

Parameters:

observer - the SingleObserver to handle, not null

getValue

@Nullable
public T getValue()

Returns the success value if this SingleSubject was terminated with a success value.

Returns:

the success value or null

hasValue

public boolean hasValue()

Returns true if this SingleSubject was terminated with a success value.

Returns:

true if this SingleSubject was terminated with a success value

getThrowable

@Nullable
public @Nullable Throwable getThrowable()

Returns the terminal error if this SingleSubject has been terminated with an error, null otherwise.

Returns:

the terminal error or null if not terminated or not with an error

hasThrowable

public boolean hasThrowable()

Returns true if this SingleSubject has been terminated with an error.

Returns:

true if this SingleSubject has been terminated with an error

hasObservers

public boolean hasObservers()

Returns true if this SingleSubject has observers.

Returns:

true if this SingleSubject has observers