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

Packages that use SingleObserver

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.internal.disposables
io.reactivex.rxjava3.internal.jdk8
io.reactivex.rxjava3.internal.observers
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.mixed
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.util
io.reactivex.rxjava3.observers	Default wrappers and implementations for observer-based consumer classes and interfaces, including disposable and resource-tracking variants and the TestObserver that allows unit testing Observable-, Single-, Maybe- and Completable-based flows.
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.

Uses of SingleObserver in io.reactivex.rxjava3.core

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

Modifier and Type	Method	Description
<@NonNull E extends SingleObserver<? super @NonNull T>> E	Single.subscribeWith(@NonNull E observer)	Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.

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

Modifier and Type	Method	Description
@NonNull SingleObserver<? super Upstream>	SingleOperator.apply(@NonNull SingleObserver<? super @NonNull Downstream> observer)	Applies a function to the child SingleObserver and returns a new parent SingleObserver.

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

Modifier and Type	Method	Description
@NonNull SingleObserver<? super Upstream>	SingleOperator.apply(@NonNull SingleObserver<? super @NonNull Downstream> observer)	Applies a function to the child SingleObserver and returns a new parent SingleObserver.
void	Single.blockingSubscribe(@NonNull SingleObserver<? super @NonNull T> observer)	Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread.
void	Single.safeSubscribe(@NonNull SingleObserver<? super @NonNull T> observer)	Wraps the given SingleObserver, catches any RuntimeExceptions thrown by its onSubscribe(Disposable), onSuccess(Object) or onError(Throwable) methods* and routes those to the global error handler via RxJavaPlugins.onError(Throwable).
void	Single.subscribe(@NonNull SingleObserver<? super @NonNull T> observer)
void	SingleSource.subscribe(@NonNull SingleObserver<? super @NonNull T> observer)	Subscribes the given SingleObserver to this SingleSource instance.
protected abstract void	Single.subscribeActual(@NonNull SingleObserver<? super @NonNull T> observer)	Implement this method in subclasses to handle the incoming SingleObservers.

Uses of SingleObserver in io.reactivex.rxjava3.internal.disposables

Methods in io.reactivex.rxjava3.internal.disposables with parameters of type SingleObserver

Modifier and Type	Method	Description
static void	EmptyDisposable.error(java.lang.Throwable e, SingleObserver<?> observer)

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

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

Modifier and Type	Class	Description
class	CompletionStageConsumer<T>	Class that extends CompletableFuture and converts multiple types of reactive consumers and their signals into completion signals.
(package private) static class	MaybeFlattenStreamAsFlowable.FlattenStreamMultiObserver<T,R>
(package private) static class	MaybeFlattenStreamAsObservable.FlattenStreamMultiObserver<T,R>
(package private) static class	SingleMapOptional.MapOptionalSingleObserver<T,R>

Fields in io.reactivex.rxjava3.internal.jdk8 declared as SingleObserver

Modifier and Type	Field	Description
(package private) SingleObserver<? super R>	FlowableCollectWithCollectorSingle.CollectorSingleObserver.downstream
(package private) SingleObserver<? super R>	ObservableCollectWithCollectorSingle.CollectorSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleFromCompletionStage.CompletionStageHandler.downstream

Methods in io.reactivex.rxjava3.internal.jdk8 with parameters of type SingleObserver

Modifier and Type	Method	Description
protected void	FlowableCollectWithCollectorSingle.subscribeActual(@NonNull SingleObserver<? super R> observer)
protected void	ObservableCollectWithCollectorSingle.subscribeActual(@NonNull SingleObserver<? super R> observer)
protected void	SingleFromCompletionStage.subscribeActual(SingleObserver<? super T> observer)

Constructors in io.reactivex.rxjava3.internal.jdk8 with parameters of type SingleObserver

Constructor	Description
CollectorSingleObserver(SingleObserver<? super R> downstream, A container, java.util.function.BiConsumer<A,T> accumulator, java.util.function.Function<A,R> finisher)
CollectorSingleObserver(SingleObserver<? super R> downstream, A container, java.util.function.BiConsumer<A,T> accumulator, java.util.function.Function<A,R> finisher)
CompletionStageHandler(SingleObserver<? super T> downstream, FlowableFromCompletionStage.BiConsumerAtomicReference<T> whenReference)

Uses of SingleObserver in io.reactivex.rxjava3.internal.observers

Classes in io.reactivex.rxjava3.internal.observers that implement SingleObserver

Modifier and Type	Class	Description
class	BiConsumerSingleObserver<T>
class	BlockingDisposableMultiObserver<T>	Blocks until the upstream terminates and dispatches the outcome to the actual observer.
class	BlockingMultiObserver<T>	A combined Observer that awaits the success or error signal via a CountDownLatch.
class	ConsumerSingleObserver<T>
class	DisposableAutoReleaseMultiObserver<T>	Wraps lambda callbacks and when the upstream terminates or this (Single | Maybe | Completable) observer gets disposed, removes itself from a CompositeDisposable.
class	FutureMultiObserver<T>	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
class	ResumeSingleObserver<T>	A SingleObserver implementation used for subscribing to the actual SingleSource and replace the current Disposable in a parent AtomicReference.
class	SafeSingleObserver<T>	Wraps another SingleObserver and catches exceptions thrown by its onSubscribe, onSuccess or onError methods despite the protocol forbids it.

Fields in io.reactivex.rxjava3.internal.observers declared as SingleObserver

Modifier and Type	Field	Description
(package private) SingleObserver<? super T>	ResumeSingleObserver.downstream
(package private) SingleObserver<? super T>	SafeSingleObserver.downstream

Methods in io.reactivex.rxjava3.internal.observers with parameters of type SingleObserver

Modifier and Type	Method	Description
void	BlockingDisposableMultiObserver.blockingConsume(SingleObserver<? super T> observer)

Constructors in io.reactivex.rxjava3.internal.observers with parameters of type SingleObserver

Constructor	Description
ResumeSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, SingleObserver<? super T> downstream)
SafeSingleObserver(SingleObserver<? super T> downstream)

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

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

Modifier and Type	Class	Description
(package private) static class	CompletableFromSingle.CompletableFromSingleObserver<T>

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

Modifier and Type	Field	Description
private SingleObserver<? super T>	CompletableToSingle.ToSingle.observer

Methods in io.reactivex.rxjava3.internal.operators.completable with parameters of type SingleObserver

Modifier and Type	Method	Description
protected void	CompletableMaterialize.subscribeActual(SingleObserver<? super Notification<T>> observer)
protected void	CompletableToSingle.subscribeActual(SingleObserver<? super T> observer)

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

Constructor	Description
ToSingle(SingleObserver<? super T> observer)

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

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

Modifier and Type	Class	Description
(package private) static class	FlowableConcatWithSingle.ConcatWithSubscriber<T>
(package private) class	FlowableFlatMapSingle.FlatMapSingleSubscriber.InnerObserver
(package private) static class	FlowableMergeWithSingle.MergeWithObserver.OtherObserver<T>

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

Modifier and Type	Field	Description
(package private) SingleObserver<? super java.lang.Boolean>	FlowableAllSingle.AllSubscriber.downstream
(package private) SingleObserver<? super java.lang.Boolean>	FlowableAnySingle.AnySubscriber.downstream
(package private) SingleObserver<? super U>	FlowableCollectSingle.CollectSubscriber.downstream
(package private) SingleObserver<? super java.lang.Long>	FlowableCountSingle.CountSubscriber.downstream
(package private) SingleObserver<? super T>	FlowableElementAtSingle.ElementAtSubscriber.downstream
(package private) SingleObserver<? super T>	FlowableLastSingle.LastSubscriber.downstream
(package private) SingleObserver<? super R>	FlowableReduceSeedSingle.ReduceSeedObserver.downstream
(package private) SingleObserver<? super java.lang.Boolean>	FlowableSequenceEqualSingle.EqualCoordinator.downstream
(package private) SingleObserver<? super T>	FlowableSingleSingle.SingleElementSubscriber.downstream
(package private) SingleObserver<? super U>	FlowableToListSingle.ToListSubscriber.downstream

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type SingleObserver

Modifier and Type	Method	Description
protected void	FlowableAllSingle.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	FlowableAnySingle.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	FlowableCollectSingle.subscribeActual(SingleObserver<? super U> observer)
protected void	FlowableCountSingle.subscribeActual(SingleObserver<? super java.lang.Long> observer)
protected void	FlowableElementAtSingle.subscribeActual(SingleObserver<? super T> observer)
protected void	FlowableLastSingle.subscribeActual(SingleObserver<? super T> observer)
protected void	FlowableReduceSeedSingle.subscribeActual(SingleObserver<? super R> observer)
protected void	FlowableReduceWithSingle.subscribeActual(SingleObserver<? super R> observer)
void	FlowableSequenceEqualSingle.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	FlowableSingleSingle.subscribeActual(SingleObserver<? super T> observer)
protected void	FlowableToListSingle.subscribeActual(SingleObserver<? super U> observer)

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

Constructor	Description
AllSubscriber(SingleObserver<? super java.lang.Boolean> actual, Predicate<? super T> predicate)
AnySubscriber(SingleObserver<? super java.lang.Boolean> actual, Predicate<? super T> predicate)
CollectSubscriber(SingleObserver<? super U> actual, U u, BiConsumer<? super U,? super T> collector)
CountSubscriber(SingleObserver<? super java.lang.Long> downstream)
ElementAtSubscriber(SingleObserver<? super T> actual, long index, T defaultValue)
EqualCoordinator(SingleObserver<? super java.lang.Boolean> actual, int prefetch, BiPredicate<? super T,? super T> comparer)
LastSubscriber(SingleObserver<? super T> actual, T defaultItem)
ReduceSeedObserver(SingleObserver<? super R> actual, BiFunction<R,? super T,R> reducer, R value)
SingleElementSubscriber(SingleObserver<? super T> actual, T defaultValue)
ToListSubscriber(SingleObserver<? super U> actual, U collection)

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

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

Modifier and Type	Class	Description
(package private) static class	MaybeFilterSingle.FilterMaybeObserver<T>
(package private) static class	MaybeFlatMapSingle.FlatMapSingleObserver<R>
(package private) static class	MaybeFromSingle.FromSingleObserver<T>
static class	MaybeOnErrorComplete.OnErrorCompleteMultiObserver<T>
(package private) static class	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver<T>

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

Modifier and Type	Field	Description
(package private) SingleObserver<? super java.lang.Boolean>	MaybeContains.ContainsMaybeObserver.downstream
(package private) SingleObserver<? super java.lang.Long>	MaybeCount.CountMaybeObserver.downstream
(package private) SingleObserver<? super java.lang.Boolean>	MaybeEqualSingle.EqualCoordinator.downstream
(package private) SingleObserver<? super java.lang.Boolean>	MaybeIsEmptySingle.IsEmptyMaybeObserver.downstream
(package private) SingleObserver<? super T>	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.downstream
(package private) SingleObserver<? super T>	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver.OtherSingleObserver.downstream
(package private) SingleObserver<? super T>	MaybeToSingle.ToSingleMaybeSubscriber.downstream

Methods in io.reactivex.rxjava3.internal.operators.maybe with parameters of type SingleObserver

Modifier and Type	Method	Description
protected void	MaybeContains.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	MaybeCount.subscribeActual(SingleObserver<? super java.lang.Long> observer)
protected void	MaybeEqualSingle.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	MaybeIsEmptySingle.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	MaybeMaterialize.subscribeActual(SingleObserver<? super Notification<T>> observer)
protected void	MaybeSwitchIfEmptySingle.subscribeActual(SingleObserver<? super T> observer)
protected void	MaybeToSingle.subscribeActual(SingleObserver<? super T> observer)

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

Constructor	Description
ContainsMaybeObserver(SingleObserver<? super java.lang.Boolean> actual, java.lang.Object value)
CountMaybeObserver(SingleObserver<? super java.lang.Long> downstream)
EqualCoordinator(SingleObserver<? super java.lang.Boolean> actual, BiPredicate<? super T,? super T> isEqual)
IsEmptyMaybeObserver(SingleObserver<? super java.lang.Boolean> downstream)
OtherSingleObserver(SingleObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> parent)
SwitchIfEmptyMaybeObserver(SingleObserver<? super T> actual, SingleSource<? extends T> other)
ToSingleMaybeSubscriber(SingleObserver<? super T> actual, T defaultValue)

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

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

Modifier and Type	Class	Description
(package private) static class	FlowableConcatMapSingle.ConcatMapSingleSubscriber.ConcatMapSingleObserver<R>
(package private) static class	FlowableSwitchMapSingle.SwitchMapSingleSubscriber.SwitchMapSingleObserver<R>
class	MaterializeSingleObserver<T>	A consumer that implements the consumer types of Maybe, Single and Completable and turns their signals into Notifications for a SingleObserver.
(package private) static class	ObservableConcatMapSingle.ConcatMapSingleMainObserver.ConcatMapSingleObserver<R>
(package private) static class	ObservableSwitchMapSingle.SwitchMapSingleMainObserver.SwitchMapSingleObserver<R>
(package private) static class	SingleFlatMapObservable.FlatMapObserver<T,R>

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

Modifier and Type	Field	Description
(package private) SingleObserver<? super Notification<T>>	MaterializeSingleObserver.downstream

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

Constructor	Description
MaterializeSingleObserver(SingleObserver<? super Notification<T>> downstream)

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

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

Modifier and Type	Class	Description
(package private) static class	ObservableConcatWithSingle.ConcatWithObserver<T>
(package private) class	ObservableFlatMapSingle.FlatMapSingleObserver.InnerObserver
(package private) static class	ObservableMergeWithSingle.MergeWithObserver.OtherObserver<T>

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

Modifier and Type	Field	Description
(package private) SingleObserver<? super java.lang.Boolean>	ObservableAllSingle.AllObserver.downstream
(package private) SingleObserver<? super java.lang.Boolean>	ObservableAnySingle.AnyObserver.downstream
(package private) SingleObserver<? super U>	ObservableCollectSingle.CollectObserver.downstream
(package private) SingleObserver<? super java.lang.Long>	ObservableCountSingle.CountObserver.downstream
(package private) SingleObserver<? super T>	ObservableElementAtSingle.ElementAtObserver.downstream
(package private) SingleObserver<? super T>	ObservableLastSingle.LastObserver.downstream
(package private) SingleObserver<? super R>	ObservableReduceSeedSingle.ReduceSeedObserver.downstream
(package private) SingleObserver<? super java.lang.Boolean>	ObservableSequenceEqualSingle.EqualCoordinator.downstream
(package private) SingleObserver<? super T>	ObservableSingleSingle.SingleElementObserver.downstream
(package private) SingleObserver<? super U>	ObservableToListSingle.ToListObserver.downstream

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

Modifier and Type	Method	Description
protected void	ObservableAllSingle.subscribeActual(SingleObserver<? super java.lang.Boolean> t)
protected void	ObservableAnySingle.subscribeActual(SingleObserver<? super java.lang.Boolean> t)
protected void	ObservableCollectSingle.subscribeActual(SingleObserver<? super U> t)
void	ObservableCountSingle.subscribeActual(SingleObserver<? super java.lang.Long> t)
void	ObservableElementAtSingle.subscribeActual(SingleObserver<? super T> t)
protected void	ObservableLastSingle.subscribeActual(SingleObserver<? super T> observer)
protected void	ObservableReduceSeedSingle.subscribeActual(SingleObserver<? super R> observer)
protected void	ObservableReduceWithSingle.subscribeActual(SingleObserver<? super R> observer)
void	ObservableSequenceEqualSingle.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
void	ObservableSingleSingle.subscribeActual(SingleObserver<? super T> t)
void	ObservableToListSingle.subscribeActual(SingleObserver<? super U> t)

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

Constructor	Description
AllObserver(SingleObserver<? super java.lang.Boolean> actual, Predicate<? super T> predicate)
AnyObserver(SingleObserver<? super java.lang.Boolean> actual, Predicate<? super T> predicate)
CollectObserver(SingleObserver<? super U> actual, U u, BiConsumer<? super U,? super T> collector)
CountObserver(SingleObserver<? super java.lang.Long> downstream)
ElementAtObserver(SingleObserver<? super T> actual, long index, T defaultValue)
EqualCoordinator(SingleObserver<? super java.lang.Boolean> actual, int bufferSize, ObservableSource<? extends T> first, ObservableSource<? extends T> second, BiPredicate<? super T,? super T> comparer)
LastObserver(SingleObserver<? super T> actual, T defaultItem)
ReduceSeedObserver(SingleObserver<? super R> actual, BiFunction<R,? super T,R> reducer, R value)
SingleElementObserver(SingleObserver<? super T> actual, T defaultValue)
ToListObserver(SingleObserver<? super U> actual, U collection)

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

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

Modifier and Type	Class	Description
(package private) static class	SingleAmb.AmbSingleObserver<T>
class	SingleCache<T>
(package private) class	SingleContains.ContainsSingleObserver
(package private) class	SingleDelay.Delay
(package private) static class	SingleDelayWithSingle.OtherObserver<T,U>
(package private) static class	SingleDematerialize.DematerializeObserver<T,R>
(package private) static class	SingleDetach.DetachSingleObserver<T>
(package private) static class	SingleDoAfterSuccess.DoAfterObserver<T>
(package private) static class	SingleDoAfterTerminate.DoAfterTerminateObserver<T>
(package private) static class	SingleDoFinally.DoFinallyObserver<T>
(package private) static class	SingleDoOnDispose.DoOnDisposeObserver<T>
(package private) class	SingleDoOnError.DoOnError
(package private) class	SingleDoOnEvent.DoOnEvent
(package private) static class	SingleDoOnLifecycle.SingleLifecycleObserver<T>
(package private) static class	SingleDoOnSubscribe.DoOnSubscribeSingleObserver<T>
(package private) class	SingleDoOnSuccess.DoOnSuccess
(package private) class	SingleDoOnTerminate.DoOnTerminate
(package private) static class	SingleEquals.InnerObserver<T>
(package private) static class	SingleFlatMap.SingleFlatMapCallback<T,R>
(package private) static class	SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver<R>
(package private) static class	SingleFlatMapBiSelector.FlatMapBiMainObserver<T,U,R>
(package private) static class	SingleFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver<T,U,R>
(package private) static class	SingleFlatMapCompletable.FlatMapCompletableObserver<T>
(package private) static class	SingleFlatMapIterableFlowable.FlatMapIterableObserver<T,R>
(package private) static class	SingleFlatMapIterableObservable.FlatMapIterableObserver<T,R>
(package private) static class	SingleFlatMapMaybe.FlatMapSingleObserver<T,R>
(package private) static class	SingleFlatMapNotification.FlatMapSingleObserver<T,R>
(package private) class	SingleFlatMapNotification.FlatMapSingleObserver.InnerObserver
(package private) static class	SingleFlatMapPublisher.SingleFlatMapPublisherObserver<S,T>
(package private) static class	SingleHide.HideSingleObserver<T>
(package private) static class	SingleMap.MapSingleObserver<T,R>
(package private) static class	SingleObserveOn.ObserveOnSingleObserver<T>
(package private) class	SingleOnErrorReturn.OnErrorReturn
(package private) static class	SingleResumeNext.ResumeMainSingleObserver<T>
(package private) static class	SingleSubscribeOn.SubscribeOnObserver<T>
(package private) static class	SingleTakeUntil.TakeUntilMainObserver<T>
(package private) static class	SingleTimeInterval.TimeIntervalSingleObserver<T>
(package private) static class	SingleTimeout.TimeoutMainObserver<T>
(package private) static class	SingleTimeout.TimeoutMainObserver.TimeoutFallbackObserver<T>
(package private) static class	SingleToFlowable.SingleToFlowableObserver<T>
(package private) static class	SingleToObservable.SingleToObservableObserver<T>
(package private) static class	SingleUnsubscribeOn.UnsubscribeOnSingleObserver<T>
(package private) static class	SingleUsing.UsingSingleObserver<T,U>
(package private) static class	SingleZipArray.ZipSingleObserver<T>

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

Modifier and Type	Field	Description
(package private) SingleObserver<? super T>	SingleAmb.AmbSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleCache.CacheDisposable.downstream
private SingleObserver<? super java.lang.Boolean>	SingleContains.ContainsSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleCreate.Emitter.downstream
(package private) SingleObserver<? super T>	SingleDelay.Delay.downstream
(package private) SingleObserver<? super T>	SingleDelayWithCompletable.OtherObserver.downstream
(package private) SingleObserver<? super T>	SingleDelayWithObservable.OtherSubscriber.downstream
(package private) SingleObserver<? super T>	SingleDelayWithPublisher.OtherSubscriber.downstream
(package private) SingleObserver<? super T>	SingleDelayWithSingle.OtherObserver.downstream
(package private) SingleObserver<? super T>	SingleDetach.DetachSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleDoAfterSuccess.DoAfterObserver.downstream
(package private) SingleObserver<? super T>	SingleDoAfterTerminate.DoAfterTerminateObserver.downstream
(package private) SingleObserver<? super T>	SingleDoFinally.DoFinallyObserver.downstream
(package private) SingleObserver<? super T>	SingleDoOnDispose.DoOnDisposeObserver.downstream
private SingleObserver<? super T>	SingleDoOnError.DoOnError.downstream
private SingleObserver<? super T>	SingleDoOnEvent.DoOnEvent.downstream
(package private) SingleObserver<? super T>	SingleDoOnLifecycle.SingleLifecycleObserver.downstream
(package private) SingleObserver<? super T>	SingleDoOnSubscribe.DoOnSubscribeSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleDoOnSuccess.DoOnSuccess.downstream
(package private) SingleObserver<? super T>	SingleDoOnTerminate.DoOnTerminate.downstream
(package private) SingleObserver<? super java.lang.Boolean>	SingleEquals.InnerObserver.downstream
(package private) SingleObserver<? super R>	SingleFlatMap.SingleFlatMapCallback.downstream
(package private) SingleObserver<? super R>	SingleFlatMap.SingleFlatMapCallback.FlatMapSingleObserver.downstream
(package private) SingleObserver<? super R>	SingleFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver.downstream
(package private) SingleObserver<? super R>	SingleFlatMapNotification.FlatMapSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleFromPublisher.ToSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleHide.HideSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleObserveOn.ObserveOnSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleResumeNext.ResumeMainSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleSubscribeOn.SubscribeOnObserver.downstream
(package private) SingleObserver<? super T>	SingleTakeUntil.TakeUntilMainObserver.downstream
(package private) SingleObserver<? super Timed<T>>	SingleTimeInterval.TimeIntervalSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleTimeout.TimeoutMainObserver.downstream
(package private) SingleObserver<? super T>	SingleTimeout.TimeoutMainObserver.TimeoutFallbackObserver.downstream
(package private) SingleObserver<? super java.lang.Long>	SingleTimer.TimerDisposable.downstream
(package private) SingleObserver<? super T>	SingleUnsubscribeOn.UnsubscribeOnSingleObserver.downstream
(package private) SingleObserver<? super T>	SingleUsing.UsingSingleObserver.downstream
(package private) SingleObserver<? super R>	SingleZipArray.ZipCoordinator.downstream
private SingleObserver<? super T>	SingleOnErrorReturn.OnErrorReturn.observer
(package private) SingleObserver<? super R>	SingleMap.MapSingleObserver.t

Methods in io.reactivex.rxjava3.internal.operators.single that return SingleObserver

Modifier and Type	Method	Description
static <T> SingleObserver<T>	SingleToObservable.create(Observer<? super T> downstream)	Creates a SingleObserver wrapper around a Observer.

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

Modifier and Type	Method	Description
protected void	SingleAmb.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleCache.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleContains.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	SingleCreate.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDefer.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDelay.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDelayWithCompletable.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDelayWithObservable.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDelayWithPublisher.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDelayWithSingle.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDetach.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoAfterSuccess.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoAfterTerminate.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoFinally.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnDispose.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnError.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnEvent.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnLifecycle.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnSubscribe.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnSuccess.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleDoOnTerminate.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleEquals.subscribeActual(SingleObserver<? super java.lang.Boolean> observer)
protected void	SingleError.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleFlatMap.subscribeActual(SingleObserver<? super R> downstream)
protected void	SingleFlatMapBiSelector.subscribeActual(SingleObserver<? super R> observer)
protected void	SingleFlatMapNotification.subscribeActual(SingleObserver<? super R> observer)
protected void	SingleFromCallable.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleFromPublisher.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleFromSupplier.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleFromUnsafeSource.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleHide.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleJust.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleLift.subscribeActual(SingleObserver<? super R> observer)
protected void	SingleMap.subscribeActual(SingleObserver<? super R> t)
protected void	SingleMaterialize.subscribeActual(SingleObserver<? super Notification<T>> observer)
protected void	SingleNever.subscribeActual(SingleObserver<? super java.lang.Object> observer)
protected void	SingleObserveOn.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleOnErrorReturn.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleResumeNext.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleSubscribeOn.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleTakeUntil.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleTimeInterval.subscribeActual(@NonNull SingleObserver<? super @NonNull Timed<T>> observer)
protected void	SingleTimeout.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleTimer.subscribeActual(SingleObserver<? super java.lang.Long> observer)
protected void	SingleUnsubscribeOn.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleUsing.subscribeActual(SingleObserver<? super T> observer)
protected void	SingleZipArray.subscribeActual(SingleObserver<? super R> observer)
protected void	SingleZipIterable.subscribeActual(SingleObserver<? super R> observer)

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

Constructor	Description
AmbSingleObserver(SingleObserver<? super T> observer, CompositeDisposable set, java.util.concurrent.atomic.AtomicBoolean winner)
CacheDisposable(SingleObserver<? super T> actual, SingleCache<T> parent)
ContainsSingleObserver(SingleObserver<? super java.lang.Boolean> observer)
Delay(SequentialDisposable sd, SingleObserver<? super T> observer)
DetachSingleObserver(SingleObserver<? super T> downstream)
DoAfterObserver(SingleObserver<? super T> actual, Consumer<? super T> onAfterSuccess)
DoAfterTerminateObserver(SingleObserver<? super T> actual, Action onAfterTerminate)
DoFinallyObserver(SingleObserver<? super T> actual, Action onFinally)
DoOnDisposeObserver(SingleObserver<? super T> actual, Action onDispose)
DoOnError(SingleObserver<? super T> observer)
DoOnEvent(SingleObserver<? super T> observer)
DoOnSubscribeSingleObserver(SingleObserver<? super T> actual, Consumer<? super Disposable> onSubscribe)
DoOnSuccess(SingleObserver<? super T> observer)
DoOnTerminate(SingleObserver<? super T> observer)
Emitter(SingleObserver<? super T> downstream)
FlatMapBiMainObserver(SingleObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
FlatMapSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, SingleObserver<? super R> downstream)
FlatMapSingleObserver(SingleObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends SingleSource<? extends R>> onErrorMapper)
HideSingleObserver(SingleObserver<? super T> downstream)
InnerObserver(int index, CompositeDisposable set, java.lang.Object[] values, SingleObserver<? super java.lang.Boolean> observer, java.util.concurrent.atomic.AtomicInteger count)
InnerObserver(SingleObserver<? super R> actual, BiFunction<? super T,? super U,? extends R> resultSelector)
MapSingleObserver(SingleObserver<? super R> t, Function<? super T,? extends R> mapper)
ObserveOnSingleObserver(SingleObserver<? super T> actual, Scheduler scheduler)
OnErrorReturn(SingleObserver<? super T> observer)
OtherObserver(SingleObserver<? super T> actual, SingleSource<T> source)
OtherObserver(SingleObserver<? super T> actual, SingleSource<T> source)
OtherSubscriber(SingleObserver<? super T> actual, SingleSource<T> source)
OtherSubscriber(SingleObserver<? super T> actual, SingleSource<T> source)
ResumeMainSingleObserver(SingleObserver<? super T> actual, Function<? super java.lang.Throwable,? extends SingleSource<? extends T>> nextFunction)
SingleFlatMapCallback(SingleObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> mapper)
SingleLifecycleObserver(SingleObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
SubscribeOnObserver(SingleObserver<? super T> actual, SingleSource<? extends T> source)
TakeUntilMainObserver(SingleObserver<? super T> downstream)
TimeIntervalSingleObserver(SingleObserver<? super Timed<T>> downstream, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean start)
TimeoutFallbackObserver(SingleObserver<? super T> downstream)
TimeoutMainObserver(SingleObserver<? super T> actual, SingleSource<? extends T> other, long timeout, java.util.concurrent.TimeUnit unit)
TimerDisposable(SingleObserver<? super java.lang.Long> downstream)
ToSingleObserver(SingleObserver<? super T> downstream)
UnsubscribeOnSingleObserver(SingleObserver<? super T> actual, Scheduler scheduler)
UsingSingleObserver(SingleObserver<? super T> actual, U resource, boolean eager, Consumer<? super U> disposer)
ZipCoordinator(SingleObserver<? super R> observer, int n, Function<? super java.lang.Object[],? extends R> zipper)

Uses of SingleObserver in io.reactivex.rxjava3.internal.util

Classes in io.reactivex.rxjava3.internal.util that implement SingleObserver

Modifier and Type	Class	Description
class	EmptyComponent	Singleton implementing many interfaces as empty.

Methods in io.reactivex.rxjava3.internal.util with parameters of type SingleObserver

Modifier and Type	Method	Description
void	AtomicThrowable.tryTerminateConsumer(SingleObserver<?> consumer)	Tries to terminate this atomic throwable (by swapping in the TERMINATED indicator) and notifies the consumer if there was no error (onComplete) or there was a non-null, non-indicator exception contained before (onError).

Uses of SingleObserver in io.reactivex.rxjava3.observers

Classes in io.reactivex.rxjava3.observers that implement SingleObserver

Modifier and Type	Class	Description
class	DisposableSingleObserver<T>	An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.
class	ResourceSingleObserver<T>	An abstract SingleObserver that allows asynchronous cancellation of its subscription and the associated resources.
class	TestObserver<T>	An Observer, MaybeObserver, SingleObserver and CompletableObserver composite that can record events from Observables, Maybes, Singles and Completables and allows making assertions about them.

Uses of SingleObserver in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins with type parameters of type SingleObserver

Modifier and Type	Field	Description
(package private) static @Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver>	RxJavaPlugins.onSingleSubscribe
(package private) static @Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver>	RxJavaPlugins.onSingleSubscribe

Methods in io.reactivex.rxjava3.plugins that return SingleObserver

Modifier and Type	Method	Description
static <@NonNull T> @NonNull SingleObserver<? super T>	RxJavaPlugins.onSubscribe(@NonNull Single<@NonNull T> source, @NonNull SingleObserver<? super @NonNull T> observer)	Calls the associated hook function.

Methods in io.reactivex.rxjava3.plugins that return types with arguments of type SingleObserver

Modifier and Type	Method	Description
static @Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver>	RxJavaPlugins.getOnSingleSubscribe()	Returns the current hook function.
static @Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver>	RxJavaPlugins.getOnSingleSubscribe()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type SingleObserver

Modifier and Type	Method	Description
static <@NonNull T> @NonNull SingleObserver<? super T>	RxJavaPlugins.onSubscribe(@NonNull Single<@NonNull T> source, @NonNull SingleObserver<? super @NonNull T> observer)	Calls the associated hook function.

Method parameters in io.reactivex.rxjava3.plugins with type arguments of type SingleObserver

Modifier and Type	Method	Description
static void	RxJavaPlugins.setOnSingleSubscribe(@Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver> onSingleSubscribe)	Sets the specific hook function.
static void	RxJavaPlugins.setOnSingleSubscribe(@Nullable BiFunction<? super Single,? super SingleObserver,? extends SingleObserver> onSingleSubscribe)	Sets the specific hook function.

Uses of SingleObserver in io.reactivex.rxjava3.subjects

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

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

Fields in io.reactivex.rxjava3.subjects declared as SingleObserver

Modifier and Type	Field	Description
(package private) SingleObserver<? super T>	SingleSubject.SingleDisposable.downstream

Methods in io.reactivex.rxjava3.subjects with parameters of type SingleObserver

Modifier and Type	Method	Description
protected void	SingleSubject.subscribeActual(@NonNull SingleObserver<? super T> observer)

Constructors in io.reactivex.rxjava3.subjects with parameters of type SingleObserver

Constructor	Description
SingleDisposable(SingleObserver<? super T> actual, SingleSubject<T> parent)