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
<@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.
void	Maybe.blockingSubscribe(@NonNull MaybeObserver<? super @NonNull T> observer)	Subscribes to the current Maybe and calls the appropriate MaybeObserver method on the current thread.
void	Maybe.safeSubscribe(@NonNull MaybeObserver<? super @NonNull T> observer)	Wraps the given MaybeObserver, catches any RuntimeExceptions thrown by its onSubscribe(Disposable), onSuccess(Object), onError(Throwable) or onComplete() methods and routes those to the global error handler via RxJavaPlugins.onError(Throwable).
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(java.lang.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
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	MaybeMapOptional.MapOptionalMaybeObserver<T,R>

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	MaybeFromCompletionStage.CompletionStageHandler.downstream
(package private) MaybeObserver<? super R>	MaybeMapOptional.MapOptionalMaybeObserver.downstream
(package private) MaybeObserver<? super R>	SingleMapOptional.MapOptionalSingleObserver.downstream

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)

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

Constructor	Description
CompletionStageHandler(MaybeObserver<? super T> downstream, FlowableFromCompletionStage.BiConsumerAtomicReference<T> whenReference)
MapOptionalMaybeObserver(MaybeObserver<? super R> downstream, Function<? super T,java.util.Optional<? extends R>> mapper)
MapOptionalSingleObserver(MaybeObserver<? super R> downstream, Function<? super T,java.util.Optional<? extends R>> mapper)

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

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

Modifier and Type	Class	Description
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	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	SafeMaybeObserver<T>	Wraps another MaybeObserver and catches exceptions thrown by its onSubscribe, onSuccess, onError or onComplete methods despite the protocol forbids it.

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	SafeMaybeObserver.downstream

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

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

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

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	CompletableOnErrorReturn.OnErrorReturnMaybeObserver.downstream

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)

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

Constructor	Description
OnErrorReturnMaybeObserver(MaybeObserver<? super T> actual, Function<? super java.lang.Throwable,? extends T> itemSupplier)

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

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

Modifier and Type	Class	Description
(package private) static class	FlowableConcatWithMaybe.ConcatWithSubscriber<T>
(package private) class	FlowableFlatMapMaybe.FlatMapMaybeSubscriber.InnerObserver
(package private) static class	FlowableMergeWithMaybe.MergeWithObserver.OtherObserver<T>

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	FlowableElementAtMaybe.ElementAtSubscriber.downstream
(package private) MaybeObserver<? super T>	FlowableLastMaybe.LastSubscriber.downstream
(package private) MaybeObserver<? super T>	FlowableReduceMaybe.ReduceSubscriber.downstream
(package private) MaybeObserver<? super T>	FlowableSingleMaybe.SingleElementSubscriber.downstream

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)

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

Constructor	Description
ElementAtSubscriber(MaybeObserver<? super T> actual, long index)
LastSubscriber(MaybeObserver<? super T> downstream)
ReduceSubscriber(MaybeObserver<? super T> actual, BiFunction<T,T,T> reducer)
SingleElementSubscriber(MaybeObserver<? super T> downstream)

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
(package private) static class	MaybeAmb.AmbMaybeObserver<T>
class	MaybeCache<T>	Consumes the source once and replays its signal to any current or future MaybeObservers.
class	MaybeCallbackObserver<T>	MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
(package private) static class	MaybeConcatArray.ConcatMaybeObserver<T>
(package private) static class	MaybeConcatArrayDelayError.ConcatMaybeObserver<T>
(package private) static class	MaybeConcatIterable.ConcatMaybeObserver<T>
(package private) static class	MaybeContains.ContainsMaybeObserver
(package private) static class	MaybeCount.CountMaybeObserver
(package private) static class	MaybeDelay.DelayMaybeObserver<T>
(package private) static class	MaybeDelayOtherPublisher.DelayMaybeObserver<T,U>
(package private) static class	MaybeDelaySubscriptionOtherPublisher.DelayMaybeObserver<T>
(package private) static class	MaybeDelayWithCompletable.DelayWithMainObserver<T>
(package private) static class	MaybeDematerialize.DematerializeObserver<T,R>
(package private) static class	MaybeDetach.DetachMaybeObserver<T>
(package private) static class	MaybeDoAfterSuccess.DoAfterObserver<T>
(package private) static class	MaybeDoFinally.DoFinallyObserver<T>
(package private) static class	MaybeDoOnEvent.DoOnEventMaybeObserver<T>
(package private) static class	MaybeDoOnLifecycle.MaybeLifecycleObserver<T>
(package private) class	MaybeDoOnTerminate.DoOnTerminate
(package private) static class	MaybeEqualSingle.EqualObserver<T>
(package private) static class	MaybeFilter.FilterMaybeObserver<T>
(package private) static class	MaybeFlatMapBiSelector.FlatMapBiMainObserver<T,U,R>
(package private) static class	MaybeFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver<T,U,R>
(package private) static class	MaybeFlatMapCompletable.FlatMapCompletableObserver<T>
(package private) static class	MaybeFlatMapIterableFlowable.FlatMapIterableObserver<T,R>
(package private) static class	MaybeFlatMapIterableObservable.FlatMapIterableObserver<T,R>
(package private) static class	MaybeFlatMapNotification.FlatMapMaybeObserver<T,R>
(package private) class	MaybeFlatMapNotification.FlatMapMaybeObserver.InnerObserver
(package private) static class	MaybeFlatMapSingle.FlatMapMaybeObserver<T,R>
(package private) static class	MaybeFlatten.FlatMapMaybeObserver<T,R>
(package private) class	MaybeFlatten.FlatMapMaybeObserver.InnerObserver
(package private) static class	MaybeHide.HideMaybeObserver<T>
(package private) static class	MaybeIgnoreElement.IgnoreMaybeObserver<T>
(package private) static class	MaybeIgnoreElementCompletable.IgnoreMaybeObserver<T>
(package private) static class	MaybeIsEmpty.IsEmptyMaybeObserver<T>
(package private) static class	MaybeIsEmptySingle.IsEmptyMaybeObserver<T>
(package private) static class	MaybeMap.MapMaybeObserver<T,R>
(package private) static class	MaybeMergeArray.MergeMaybeObserver<T>
(package private) static class	MaybeObserveOn.ObserveOnMaybeObserver<T>
static class	MaybeOnErrorComplete.OnErrorCompleteMultiObserver<T>
(package private) static class	MaybeOnErrorNext.OnErrorNextMaybeObserver<T>
(package private) static class	MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver<T>
(package private) static class	MaybeOnErrorReturn.OnErrorReturnMaybeObserver<T>
(package private) static class	MaybePeek.MaybePeekObserver<T>
(package private) static class	MaybeSubscribeOn.SubscribeOnMaybeObserver<T>
(package private) static class	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver<T>
(package private) static class	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver<T>
(package private) static class	MaybeSwitchIfEmptySingle.SwitchIfEmptyMaybeObserver<T>
(package private) static class	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver<T,U>
(package private) static class	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.TakeUntilOtherMaybeObserver<U>
(package private) static class	MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver<T,U>
(package private) static class	MaybeTimeInterval.TimeIntervalMaybeObserver<T>
(package private) static class	MaybeTimeoutMaybe.TimeoutFallbackMaybeObserver<T>
(package private) static class	MaybeTimeoutMaybe.TimeoutMainMaybeObserver<T,U>
(package private) static class	MaybeTimeoutMaybe.TimeoutOtherMaybeObserver<T,U>
(package private) static class	MaybeTimeoutPublisher.TimeoutFallbackMaybeObserver<T>
(package private) static class	MaybeTimeoutPublisher.TimeoutMainMaybeObserver<T,U>
(package private) static class	MaybeToFlowable.MaybeToFlowableSubscriber<T>
(package private) static class	MaybeToObservable.MaybeToObservableObserver<T>
(package private) static class	MaybeToSingle.ToSingleMaybeSubscriber<T>
(package private) static class	MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver<T>
(package private) static class	MaybeUsing.UsingObserver<T,D>
(package private) static class	MaybeZipArray.ZipMaybeObserver<T>

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	MaybeAmb.AmbMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeCache.CacheDisposable.downstream
(package private) MaybeObserver<? super T>	MaybeCreate.Emitter.downstream
(package private) MaybeObserver<? super T>	MaybeDelay.DelayMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDelayOtherPublisher.OtherSubscriber.downstream
(package private) MaybeObserver<? super T>	MaybeDelaySubscriptionOtherPublisher.DelayMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDelayWithCompletable.DelayWithMainObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDelayWithCompletable.OtherObserver.downstream
(package private) MaybeObserver<? super R>	MaybeDematerialize.DematerializeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDetach.DetachMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDoAfterSuccess.DoAfterObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDoFinally.DoFinallyObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDoOnEvent.DoOnEventMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDoOnLifecycle.MaybeLifecycleObserver.downstream
(package private) MaybeObserver<? super T>	MaybeDoOnTerminate.DoOnTerminate.downstream
(package private) MaybeObserver<? super T>	MaybeFilter.FilterMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeFilterSingle.FilterMaybeObserver.downstream
(package private) MaybeObserver<? super R>	MaybeFlatMapBiSelector.FlatMapBiMainObserver.InnerObserver.downstream
(package private) MaybeObserver<? super R>	MaybeFlatMapNotification.FlatMapMaybeObserver.downstream
(package private) MaybeObserver<? super R>	MaybeFlatMapSingle.FlatMapMaybeObserver.downstream
(package private) MaybeObserver<? super R>	MaybeFlatMapSingle.FlatMapSingleObserver.downstream
(package private) MaybeObserver<? super R>	MaybeFlatten.FlatMapMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeFromCompletable.FromCompletableObserver.downstream
(package private) MaybeObserver<? super T>	MaybeFromSingle.FromSingleObserver.downstream
(package private) MaybeObserver<? super T>	MaybeHide.HideMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeIgnoreElement.IgnoreMaybeObserver.downstream
(package private) MaybeObserver<? super java.lang.Boolean>	MaybeIsEmpty.IsEmptyMaybeObserver.downstream
(package private) MaybeObserver<? super R>	MaybeMap.MapMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeObserveOn.ObserveOnMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeOnErrorComplete.OnErrorCompleteMultiObserver.downstream
(package private) MaybeObserver<? super T>	MaybeOnErrorNext.OnErrorNextMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeOnErrorNext.OnErrorNextMaybeObserver.NextMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeOnErrorReturn.OnErrorReturnMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybePeek.MaybePeekObserver.downstream
(package private) MaybeObserver<? super T>	MaybeSubscribeOn.SubscribeOnMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeSwitchIfEmpty.SwitchIfEmptyMaybeObserver.OtherMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeTakeUntilMaybe.TakeUntilMainMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeTakeUntilPublisher.TakeUntilMainMaybeObserver.downstream
(package private) MaybeObserver<? super Timed<T>>	MaybeTimeInterval.TimeIntervalMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeTimeoutMaybe.TimeoutFallbackMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeTimeoutMaybe.TimeoutMainMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeTimeoutPublisher.TimeoutFallbackMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeTimeoutPublisher.TimeoutMainMaybeObserver.downstream
(package private) MaybeObserver<? super java.lang.Long>	MaybeTimer.TimerDisposable.downstream
(package private) MaybeObserver<? super T>	MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver.downstream
(package private) MaybeObserver<? super T>	MaybeUsing.UsingObserver.downstream
(package private) MaybeObserver<? super R>	MaybeZipArray.ZipCoordinator.downstream
(package private) MaybeObserver<? super T>	MaybeSubscribeOn.SubscribeTask.observer

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 java.lang.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 java.lang.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 java.lang.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 java.lang.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

Constructor	Description
AmbMaybeObserver(MaybeObserver<? super T> downstream, CompositeDisposable set, java.util.concurrent.atomic.AtomicBoolean winner)
CacheDisposable(MaybeObserver<? super T> actual, MaybeCache<T> parent)
DelayMaybeObserver(MaybeObserver<? super T> actual, long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)
DelayMaybeObserver(MaybeObserver<? super T> actual, org.reactivestreams.Publisher<U> otherSource)
DelayMaybeObserver(MaybeObserver<? super T> downstream)
DelayWithMainObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super T> downstream)
DematerializeObserver(MaybeObserver<? super R> downstream, Function<? super T,Notification<R>> selector)
DetachMaybeObserver(MaybeObserver<? super T> downstream)
DoAfterObserver(MaybeObserver<? super T> actual, Consumer<? super T> onAfterSuccess)
DoFinallyObserver(MaybeObserver<? super T> actual, Action onFinally)
DoOnEventMaybeObserver(MaybeObserver<? super T> actual, BiConsumer<? super T,? super java.lang.Throwable> onEvent)
DoOnTerminate(MaybeObserver<? super T> observer)
Emitter(MaybeObserver<? super T> downstream)
FilterMaybeObserver(MaybeObserver<? super T> actual, Predicate<? super T> predicate)
FilterMaybeObserver(MaybeObserver<? super T> actual, Predicate<? super T> predicate)
FlatMapBiMainObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends U>> mapper, BiFunction<? super T,? super U,? extends R> resultSelector)
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, Supplier<? extends MaybeSource<? extends R>> onCompleteSupplier)
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends SingleSource<? extends R>> mapper)
FlatMapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> mapper)
FlatMapSingleObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)
FromCompletableObserver(MaybeObserver<? super T> downstream)
FromSingleObserver(MaybeObserver<? super T> downstream)
HideMaybeObserver(MaybeObserver<? super T> downstream)
IgnoreMaybeObserver(MaybeObserver<? super T> downstream)
InnerObserver(MaybeObserver<? super R> actual, BiFunction<? super T,? super U,? extends R> resultSelector)
IsEmptyMaybeObserver(MaybeObserver<? super java.lang.Boolean> downstream)
MapMaybeObserver(MaybeObserver<? super R> actual, Function<? super T,? extends R> mapper)
MaybeLifecycleObserver(MaybeObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybePeekObserver(MaybeObserver<? super T> actual, MaybePeek<T> parent)
NextMaybeObserver(MaybeObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> d)
ObserveOnMaybeObserver(MaybeObserver<? super T> actual, Scheduler scheduler)
OnErrorCompleteMultiObserver(MaybeObserver<? super T> actual, Predicate<? super java.lang.Throwable> predicate)
OnErrorNextMaybeObserver(MaybeObserver<? super T> actual, Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>> resumeFunction)
OnErrorReturnMaybeObserver(MaybeObserver<? super T> actual, Function<? super java.lang.Throwable,? extends T> valueSupplier)
OtherMaybeObserver(MaybeObserver<? super T> actual, java.util.concurrent.atomic.AtomicReference<Disposable> parent)
OtherObserver(MaybeObserver<? super T> actual, MaybeSource<T> source)
OtherSubscriber(MaybeObserver<? super T> downstream)
OtherSubscriber(MaybeObserver<? super T> actual, MaybeSource<T> source)
SubscribeOnMaybeObserver(MaybeObserver<? super T> downstream)
SubscribeTask(MaybeObserver<? super T> observer, MaybeSource<T> source)
SwitchIfEmptyMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> other)
TakeUntilMainMaybeObserver(MaybeObserver<? super T> downstream)
TakeUntilMainMaybeObserver(MaybeObserver<? super T> downstream)
TimeIntervalMaybeObserver(MaybeObserver<? super Timed<T>> downstream, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean start)
TimeoutFallbackMaybeObserver(MaybeObserver<? super T> downstream)
TimeoutFallbackMaybeObserver(MaybeObserver<? super T> downstream)
TimeoutMainMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> fallback)
TimeoutMainMaybeObserver(MaybeObserver<? super T> actual, MaybeSource<? extends T> fallback)
TimerDisposable(MaybeObserver<? super java.lang.Long> downstream)
UnsubscribeOnMaybeObserver(MaybeObserver<? super T> actual, Scheduler scheduler)
UsingObserver(MaybeObserver<? super T> actual, D resource, Consumer<? super D> disposer, boolean eager)
ZipCoordinator(MaybeObserver<? super R> observer, int n, Function<? super java.lang.Object[],? extends R> zipper)

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
(package private) static class	FlowableConcatMapMaybe.ConcatMapMaybeSubscriber.ConcatMapMaybeObserver<R>
(package private) static class	FlowableSwitchMapMaybe.SwitchMapMaybeSubscriber.SwitchMapMaybeObserver<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	MaybeFlatMapObservable.FlatMapObserver<T,R>
(package private) static class	MaybeFlatMapPublisher.FlatMapPublisherSubscriber<T,R>
(package private) static class	ObservableConcatMapMaybe.ConcatMapMaybeMainObserver.ConcatMapMaybeObserver<R>
(package private) static class	ObservableSwitchMapMaybe.SwitchMapMaybeMainObserver.SwitchMapMaybeObserver<R>

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

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

Modifier and Type	Class	Description
(package private) static class	ObservableConcatWithMaybe.ConcatWithObserver<T>
(package private) class	ObservableFlatMapMaybe.FlatMapMaybeObserver.InnerObserver
(package private) static class	ObservableMergeWithMaybe.MergeWithObserver.OtherObserver<T>

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	ObservableElementAtMaybe.ElementAtObserver.downstream
(package private) MaybeObserver<? super T>	ObservableLastMaybe.LastObserver.downstream
(package private) MaybeObserver<? super T>	ObservableReduceMaybe.ReduceObserver.downstream
(package private) MaybeObserver<? super T>	ObservableSingleMaybe.SingleElementObserver.downstream

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)

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

Constructor	Description
ElementAtObserver(MaybeObserver<? super T> actual, long index)
LastObserver(MaybeObserver<? super T> downstream)
ReduceObserver(MaybeObserver<? super T> observer, BiFunction<T,T,T> reducer)
SingleElementObserver(MaybeObserver<? super T> downstream)

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

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

Modifier and Type	Class	Description
(package private) static class	SingleFlatMapMaybe.FlatMapMaybeObserver<R>

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super R>	SingleDematerialize.DematerializeObserver.downstream
(package private) MaybeObserver<? super R>	SingleFlatMapMaybe.FlatMapMaybeObserver.downstream
(package private) MaybeObserver<? super R>	SingleFlatMapMaybe.FlatMapSingleObserver.downstream

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)

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

Constructor	Description
DematerializeObserver(MaybeObserver<? super R> downstream, Function<? super T,Notification<R>> selector)
FlatMapMaybeObserver(java.util.concurrent.atomic.AtomicReference<Disposable> parent, MaybeObserver<? super R> downstream)
FlatMapSingleObserver(MaybeObserver<? super R> actual, Function<? super T,? extends MaybeSource<? extends R>> mapper)

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

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

Modifier and Type	Class	Description
class	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

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

Modifier and Type	Field	Description
(package private) static @Nullable BiFunction<? super Maybe,? super MaybeObserver,? extends MaybeObserver>	RxJavaPlugins.onMaybeSubscribe
(package private) static @Nullable BiFunction<? super Maybe,? super MaybeObserver,? extends MaybeObserver>	RxJavaPlugins.onMaybeSubscribe

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,? super MaybeObserver,? extends MaybeObserver>	RxJavaPlugins.getOnMaybeSubscribe()	Returns the current hook function.
static @Nullable BiFunction<? super Maybe,? super MaybeObserver,? 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,? extends MaybeObserver> onMaybeSubscribe)	Sets the specific hook function.
static void	RxJavaPlugins.setOnMaybeSubscribe(@Nullable BiFunction<? super Maybe,@NonNull MaybeObserver,? 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
class	MaybeSubject<T>	Represents a hot Maybe-like source and consumer of events similar to Subjects.

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

Modifier and Type	Field	Description
(package private) MaybeObserver<? super T>	MaybeSubject.MaybeDisposable.downstream

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

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

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

Constructor	Description
MaybeDisposable(MaybeObserver<? super T> actual, MaybeSubject<T> parent)