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

Packages that use MaybeObserver

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

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

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

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

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

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

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

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

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

Modifier and Type	Method	Description
static void	EmptyDisposable.complete(MaybeObserver<?> observer)
static void	EmptyDisposable.error(Throwable e, MaybeObserver<?> observer)

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

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

Modifier and Type	Class	Description
final class	CompletionStageConsumer<T>	Class that extends CompletableFuture and converts multiple types of reactive consumers and their signals into completion signals.

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

Modifier and Type	Method	Description
protected void	MaybeFromCompletionStage.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeMapOptional.subscribeActual(MaybeObserver<? super R> observer)
protected void	SingleMapOptional.subscribeActual(MaybeObserver<? super R> observer)

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

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

Modifier and Type	Class	Description
final class	BlockingDisposableMultiObserver<T>	Blocks until the upstream terminates and dispatches the outcome to the actual observer.
final class	BlockingMultiObserver<T>	A combined Observer that awaits the success or error signal via a CountDownLatch.
final class	DisposableAutoReleaseMultiObserver<T>	Wraps lambda callbacks and when the upstream terminates or this (Single | Maybe | Completable) observer gets disposed, removes itself from a CompositeDisposable.
final class	FutureMultiObserver<T>	An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
final class	SafeMaybeObserver<T>	Wraps another MaybeObserver and catches exceptions thrown by its onSubscribe, onSuccess, onError or onComplete methods despite the protocol forbids it.

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

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

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

Modifier	Constructor	Description
	SafeMaybeObserver(MaybeObserver<? super T> downstream)

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

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

Modifier and Type	Method	Description
protected void	CompletableOnErrorReturn.subscribeActual(MaybeObserver<? super T> observer)

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

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

Modifier and Type	Method	Description
protected void	FlowableElementAtMaybe.subscribeActual(MaybeObserver<? super T> observer)
protected void	FlowableElementAtMaybePublisher.subscribeActual(MaybeObserver<? super T> observer)
protected void	FlowableLastMaybe.subscribeActual(MaybeObserver<? super T> observer)
protected void	FlowableReduceMaybe.subscribeActual(MaybeObserver<? super T> observer)
protected void	FlowableSingleMaybe.subscribeActual(MaybeObserver<? super T> observer)

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

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

Modifier and Type	Class	Description
final class	MaybeCache<T>	Consumes the source once and replays its signal to any current or future MaybeObservers.
final class	MaybeCallbackObserver<T>	MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
static final class	MaybeOnErrorComplete.OnErrorCompleteMultiObserver<T>

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

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

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

Modifier and Type	Method	Description
protected void	MaybeAmb.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeCache.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeCreate.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDefer.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDelay.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDelayOtherPublisher.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDelaySubscriptionOtherPublisher.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDelayWithCompletable.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDematerialize.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeDetach.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDoAfterSuccess.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDoFinally.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDoOnEvent.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDoOnLifecycle.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeDoOnTerminate.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeEmpty.subscribeActual(MaybeObserver<? super Object> observer)
protected void	MaybeError.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeErrorCallable.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFilter.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFilterSingle.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFlatMapBiSelector.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeFlatMapNotification.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeFlatMapSingle.subscribeActual(MaybeObserver<? super R> downstream)
protected void	MaybeFlatten.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeFromAction.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFromCallable.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFromCompletable.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFromFuture.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFromRunnable.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFromSingle.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeFromSupplier.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeHide.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeIgnoreElement.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeIsEmpty.subscribeActual(MaybeObserver<? super Boolean> observer)
protected void	MaybeJust.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeLift.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeMap.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeNever.subscribeActual(MaybeObserver<? super Object> observer)
protected void	MaybeObserveOn.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeOnErrorComplete.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeOnErrorNext.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeOnErrorReturn.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybePeek.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeSubscribeOn.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeSwitchIfEmpty.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeTakeUntilMaybe.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeTakeUntilPublisher.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeTimeInterval.subscribeActual(@NonNull MaybeObserver<? super @NonNull Timed<T>> observer)
protected void	MaybeTimeoutMaybe.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeTimeoutPublisher.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeTimer.subscribeActual(MaybeObserver<? super Long> observer)
protected void	MaybeUnsafeCreate.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeUnsubscribeOn.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeUsing.subscribeActual(MaybeObserver<? super T> observer)
protected void	MaybeZipArray.subscribeActual(MaybeObserver<? super R> observer)
protected void	MaybeZipIterable.subscribeActual(MaybeObserver<? super R> observer)

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

Modifier	Constructor	Description
	OnErrorCompleteMultiObserver(MaybeObserver<? super T> actual, Predicate<? super Throwable> predicate)

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

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

Modifier and Type	Class	Description
final class	MaterializeSingleObserver<T>	A consumer that implements the consumer types of Maybe, Single and Completable and turns their signals into Notifications for a SingleObserver.

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

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

Modifier and Type	Method	Description
void	ObservableElementAtMaybe.subscribeActual(MaybeObserver<? super T> t)
protected void	ObservableLastMaybe.subscribeActual(MaybeObserver<? super T> observer)
protected void	ObservableReduceMaybe.subscribeActual(MaybeObserver<? super T> observer)
void	ObservableSingleMaybe.subscribeActual(MaybeObserver<? super T> t)

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

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

Modifier and Type	Method	Description
protected void	SingleDematerialize.subscribeActual(MaybeObserver<? super R> observer)
protected void	SingleFlatMapMaybe.subscribeActual(MaybeObserver<? super R> downstream)
protected void	SingleOnErrorComplete.subscribeActual(MaybeObserver<? super T> observer)

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

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

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

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

Modifier and Type	Method	Description
void	AtomicThrowable.tryTerminateConsumer(MaybeObserver<?> 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 MaybeObserver in io.reactivex.rxjava3.observers

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

Modifier and Type	Class	Description
class	DisposableMaybeObserver<T>	An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.
class	ResourceMaybeObserver<T>	An abstract MaybeObserver that allows asynchronous cancellation of its subscription and 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 MaybeObserver in io.reactivex.rxjava3.plugins

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

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

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

Modifier and Type	Method	Description
static @Nullable BiFunction<? super Maybe, @NonNull ? super MaybeObserver, @NonNull ? extends MaybeObserver>	RxJavaPlugins.getOnMaybeSubscribe()	Returns the current hook function.
static @Nullable BiFunction<? super Maybe, @NonNull ? super MaybeObserver, @NonNull ? extends MaybeObserver>	RxJavaPlugins.getOnMaybeSubscribe()	Returns the current hook function.

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

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

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

Modifier and Type	Method	Description
static void	RxJavaPlugins.setOnMaybeSubscribe(@Nullable BiFunction<? super Maybe, @NonNull MaybeObserver, @NonNull ? extends MaybeObserver> onMaybeSubscribe)	Sets the specific hook function.
static void	RxJavaPlugins.setOnMaybeSubscribe(@Nullable BiFunction<? super Maybe, @NonNull MaybeObserver, @NonNull ? extends MaybeObserver> onMaybeSubscribe)	Sets the specific hook function.

Uses of MaybeObserver in io.reactivex.rxjava3.subjects

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

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

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

Modifier and Type	Method	Description
protected void	MaybeSubject.subscribeActual(MaybeObserver<? super T> observer)