Class MaybeSubject<T>

java.lang.Object

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

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

Type Parameters:

T - the value type received and emitted

All Implemented Interfaces:

MaybeObserver<T>, MaybeSource<T>

public final class MaybeSubject<T>
extends Maybe<T>
implements MaybeObserver<T>

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

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

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

Since a MaybeSubject is a Maybe, calling onSuccess, onError or onComplete will move this MaybeSubject into its terminal state atomically.

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

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

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

The MaybeSubject does not support clearing its cached onSuccess value.

Scheduler:

MaybeSubject does not operate by default on a particular Scheduler and the MaybeObservers get notified on the thread where the terminating onSuccess, onError or onComplete methods were invoked.

Error handling:

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

Example usage:

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

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

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

subject1.onSuccess(1);

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

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

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

// -----------------------------------------------------

MaybeSubject<Integer> subject2 = MaybeSubject.create();

TestObserver<Integer> to3 = subject2.test();

subject2.onComplete();

// a completed MaybeSubject completes its MaybeObservers
to3.assertResult();

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

// late Observers receive the terminal signal (onComplete) too
to4.assertResult();

History: 2.0.5 - experimental

Since:

2.1

Method Summary

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

Methods inherited from class Maybe

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

Modifier and Type	Method	Description
static <@NonNull T> @NonNull Maybe<T>	amb(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Runs multiple MaybeSources provided by an Iterable sequence and signals the events of the first one that signals (disposing the rest).
static <@NonNull T> @NonNull Maybe<T>	ambArray(@NonNull MaybeSource<? extends @NonNull T>... sources)	Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).
final @NonNull Maybe<T>	ambWith(@NonNull MaybeSource<? extends T> other)	Mirrors the MaybeSource (current or provided) that first signals an event.
final T	blockingGet()	Waits in a blocking fashion until the current Maybe signals a success value (which is returned), null if completed or an exception (which is propagated).
final T	blockingGet(T defaultValue)	Waits in a blocking fashion until the current Maybe signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).
final void	blockingSubscribe()	Subscribes to the current Maybe and blocks the current thread until it terminates.
final void	blockingSubscribe(@NonNull MaybeObserver<? super T> observer)	Subscribes to the current Maybe and calls the appropriate MaybeObserver method on the current thread.
final void	blockingSubscribe(@NonNull Consumer<? super T> onSuccess)	Subscribes to the current Maybe and calls given onSuccess callback on the current thread when it completes normally.
final void	blockingSubscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError)	Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.
final void	blockingSubscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.
final @NonNull Maybe<T>	cache()	Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.
final <@NonNull U> @NonNull Maybe<U>	cast(@NonNull Class<? extends @NonNull U> clazz)	Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.
final <@NonNull R> @NonNull Maybe<R>	compose(@NonNull MaybeTransformer<? super T, ? extends @NonNull R> transformer)	Transform a Maybe by applying a particular MaybeTransformer function to it.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Flow.Publisher sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concat(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Flow.Publisher sequence as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatArray(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatArrayDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatArrayEager(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatArrayEagerDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, one after the other, one at a time and delays any errors till the all inner MaybeSources terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates the Flow.Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int prefetch)	Concatenates the Flow.Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence and runs a limited number of the inner sequences at once.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a Flow.Publisher sequence of MaybeSources eagerly into a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	concatEager(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Flow.Publisher sequence of MaybeSources eagerly into a Flowable sequence, running at most the given number of inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate and runs a limited number of inner MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Concatenates a Flow.Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate.
static <@NonNull T> @NonNull Flowable<T>	concatEagerDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Concatenates a Flow.Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the inner MaybeSources at once.
final <@NonNull R> @NonNull Maybe<R>	concatMap(@NonNull Function<? super T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, where that function returns a MaybeSource.
final @NonNull Completable	concatMapCompletable(@NonNull Function<? super T, ? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.
final <@NonNull R> @NonNull Maybe<R>	concatMapSingle(@NonNull Function<? super T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.
final @NonNull Flowable<T>	concatWith(@NonNull MaybeSource<? extends T> other)	Returns a Flowable that emits the items emitted from the current Maybe, then the other MaybeSource, one after the other, without interleaving them.
final @NonNull Single<Boolean>	contains(@NonNull Object item)	Returns a Single that emits a Boolean that indicates whether the current Maybe emitted a specified item.
final @NonNull Single<Long>	count()	Returns a Single that counts the total number of items emitted (0 or 1) by the current Maybe and emits this count as a 64-bit Long.
static <@NonNull T> @NonNull Maybe<T>	create(@NonNull MaybeOnSubscribe<@NonNull T> onSubscribe)	Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
final @NonNull Single<T>	defaultIfEmpty(T defaultItem)	Returns a Single that emits the item emitted by the current Maybe or a specified default item if the current Maybe is empty.
static <@NonNull T> @NonNull Maybe<T>	defer(@NonNull Supplier<? extends @NonNull MaybeSource<? extends @NonNull T>> supplier)	Calls a Supplier for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.
final @NonNull Maybe<T>	delay(long time, @NonNull TimeUnit unit)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	delay(long time, @NonNull TimeUnit unit, boolean delayError)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay running on the specified Scheduler.
final <@NonNull U> @NonNull Maybe<T>	delay(@NonNull Flow.Publisher<@NonNull U> delayIndicator)	Delays the emission of this Maybe until the given Flow.Publisher signals an item or completes.
final @NonNull Maybe<T>	delaySubscription(long time, @NonNull TimeUnit unit)	Returns a Maybe that delays the subscription to the current Maybe by a given amount of time.
final @NonNull Maybe<T>	delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that delays the subscription to the current Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.
final <@NonNull U> @NonNull Maybe<T>	delaySubscription(@NonNull Flow.Publisher<@NonNull U> subscriptionIndicator)	Returns a Maybe that delays the subscription to this Maybe until the other Flow.Publisher emits an element or completes normally.
final <@NonNull R> @NonNull Maybe<R>	dematerialize(@NonNull Function<? super T, @NonNull Notification<@NonNull R>> selector)	Maps the Notification success value of the current Maybe back into normal onSuccess, onError or onComplete signals.
final @NonNull Maybe<T>	doAfterSuccess(@NonNull Consumer<? super T> onAfterSuccess)	Calls the specified Consumer with the success item after this item has been emitted to the downstream.
final @NonNull Maybe<T>	doAfterTerminate(@NonNull Action onAfterTerminate)	Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.
final @NonNull Maybe<T>	doFinally(@NonNull Action onFinally)	Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.
final @NonNull Maybe<T>	doOnComplete(@NonNull Action onComplete)	Invokes an Action just before the current Maybe calls onComplete.
final @NonNull Maybe<T>	doOnDispose(@NonNull Action onDispose)	Calls the shared Action if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.
final @NonNull Maybe<T>	doOnError(@NonNull Consumer<? super Throwable> onError)	Calls the shared Consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.
final @NonNull Maybe<T>	doOnEvent(@NonNull BiConsumer<@Nullable ? super T, @Nullable ? super Throwable> onEvent)	Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.
final @NonNull Maybe<T>	doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of the sequence (subscription, disposal).
final @NonNull Maybe<T>	doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Calls the shared Consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.
final @NonNull Maybe<T>	doOnSuccess(@NonNull Consumer<? super T> onSuccess)	Calls the shared Consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.
final @NonNull Maybe<T>	doOnTerminate(@NonNull Action onTerminate)	Returns a Maybe instance that calls the given onTerminate callback just before this Maybe completes normally or with an exception.
static <@NonNull T> @NonNull Maybe<T>	empty()	Returns a (singleton) Maybe instance that calls onComplete immediately.
static <@NonNull T> @NonNull Maybe<T>	error(@NonNull Supplier<? extends @NonNull Throwable> supplier)	Returns a Maybe that invokes a MaybeObserver's onError method when the MaybeObserver subscribes to it.
static <@NonNull T> @NonNull Maybe<T>	error(@NonNull Throwable throwable)	Returns a Maybe that invokes a subscriber's onError method when the subscriber subscribes to it.
final @NonNull Maybe<T>	filter(@NonNull Predicate<? super T> predicate)	Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.
final <@NonNull R> @NonNull Maybe<R>	flatMap(@NonNull Function<? super T, ? extends MaybeSource<? extends @NonNull R>> mapper)	Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, where that function returns a MaybeSource.
final <@NonNull R> @NonNull Maybe<R>	flatMap(@NonNull Function<? super T, ? extends MaybeSource<? extends @NonNull R>> onSuccessMapper, @NonNull Function<? super Throwable, ? extends MaybeSource<? extends @NonNull R>> onErrorMapper, @NonNull Supplier<? extends MaybeSource<? extends @NonNull R>> onCompleteSupplier)	Maps the onSuccess, onError or onComplete signals of the current Maybe into a MaybeSource and emits that MaybeSource's signals.
final <@NonNull U, @NonNull R> @NonNull Maybe<R>	flatMap(@NonNull Function<? super T, ? extends MaybeSource<? extends @NonNull U>> mapper, @NonNull BiFunction<? super T, ? super @NonNull U, ? extends @NonNull R> combiner)	Returns a Maybe that emits the results of a specified function to the pair of values emitted by the current Maybe and a specified mapped MaybeSource.
final @NonNull Completable	flatMapCompletable(@NonNull Function<? super T, ? extends CompletableSource> mapper)	Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.
final <@NonNull R> @NonNull Observable<R>	flatMapObservable(@NonNull Function<? super T, ? extends ObservableSource<? extends @NonNull R>> mapper)	Returns an Observable that is based on applying a specified function to the item emitted by the current Maybe, where that function returns an ObservableSource.
final <@NonNull R> @NonNull Flowable<R>	flatMapPublisher(@NonNull Function<? super T, @NonNull ? extends Flow.Publisher<? extends @NonNull R>> mapper)	Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Maybe, where that function returns a Flow.Publisher.
final <@NonNull R> @NonNull Maybe<R>	flatMapSingle(@NonNull Function<? super T, ? extends SingleSource<? extends @NonNull R>> mapper)	Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.
final <@NonNull U> @NonNull Flowable<U>	flattenAsFlowable(@NonNull Function<? super T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Maybe into an Iterable and emits its items as a Flowable sequence.
final <@NonNull U> @NonNull Observable<U>	flattenAsObservable(@NonNull Function<? super T, @NonNull ? extends Iterable<? extends @NonNull U>> mapper)	Maps the success value of the current Maybe into an Iterable and emits its items as an Observable sequence.
final <@NonNull R> @NonNull Flowable<R>	flattenStreamAsFlowable(@NonNull Function<? super T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.
final <@NonNull R> @NonNull Observable<R>	flattenStreamAsObservable(@NonNull Function<? super T, @NonNull ? extends Stream<? extends @NonNull R>> mapper)	Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.
static <@NonNull T> @NonNull Maybe<T>	fromAction(@NonNull Action action)	Returns a Maybe instance that runs the given Action for each MaybeObserver and emits either its exception or simply completes.
static <T> @NonNull Maybe<@NonNull T>	fromCallable(@NonNull Callable<? extends @Nullable T> callable)	Returns a Maybe that invokes the given Callable for each individual MaybeObserver that subscribes and emits the resulting non-null item via onSuccess while considering a null result from the Callable as indication for valueless completion via onComplete.
static <@NonNull T> @NonNull Maybe<T>	fromCompletable(@NonNull CompletableSource completableSource)	Wraps a CompletableSource into a Maybe.
static <@NonNull T> @NonNull Maybe<@NonNull T>	fromCompletionStage(@NonNull CompletionStage<@NonNull T> stage)	Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.
static <@NonNull T> @NonNull Maybe<T>	fromFuture(@NonNull Future<? extends @NonNull T> future)	Converts a Future into a Maybe, treating a null result as an indication of emptiness.
static <@NonNull T> @NonNull Maybe<T>	fromFuture(@NonNull Future<? extends @NonNull T> future, long timeout, @NonNull TimeUnit unit)	Converts a Future into a Maybe, with a timeout on the Future.
static <@NonNull T> @NonNull Maybe<T>	fromObservable(@NonNull ObservableSource<@NonNull T> source)	Wraps an ObservableSource into a Maybe and emits the very first item or completes if the source is empty.
static <@NonNull T> @NonNull Maybe<@NonNull T>	fromOptional(@NonNull Optional<@NonNull T> optional)	Converts the existing value of the provided optional into a Maybe.just(Object) or an empty optional into an Maybe.empty() Maybe instance.
static <@NonNull T> @NonNull Maybe<T>	fromPublisher(@NonNull Flow.Publisher<@NonNull T> source)	Wraps a Flow.Publisher into a Maybe and emits the very first item or completes if the source is empty.
static <@NonNull T> @NonNull Maybe<T>	fromRunnable(@NonNull Runnable run)	Returns a Maybe instance that runs the given Runnable for each MaybeObserver and emits either its unchecked exception or simply completes.
static <@NonNull T> @NonNull Maybe<T>	fromSingle(@NonNull SingleSource<@NonNull T> single)	Wraps a SingleSource into a Maybe.
static <T> @NonNull Maybe<@NonNull T>	fromSupplier(@NonNull Supplier<? extends @Nullable T> supplier)	Returns a Maybe that invokes the given Supplier for each individual MaybeObserver that subscribes and emits the resulting non-null item via onSuccess while considering a null result from the Supplier as indication for valueless completion via onComplete.
final @NonNull Maybe<T>	hide()	Hides the identity of this Maybe and its Disposable.
final @NonNull Completable	ignoreElement()	Returns a Completable that ignores the item emitted by the current Maybe and only calls onComplete or onError.
final @NonNull Single<Boolean>	isEmpty()	Returns a Single that emits true if the current Maybe is empty, otherwise false.
static <@NonNull T> @NonNull Maybe<T>	just(@NonNull T item)	Returns a Maybe that emits a specified item.
final <@NonNull R> @NonNull Maybe<R>	lift(@NonNull MaybeOperator<? extends @NonNull R, ? super T> lift)	This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Maybe which, when subscribed to, invokes the apply(MaybeObserver) method of the provided MaybeOperator for each individual downstream Maybe and allows the insertion of a custom operator by accessing the downstream's MaybeObserver during this subscription phase and providing a new MaybeObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
final <@NonNull R> @NonNull Maybe<R>	map(@NonNull Function<? super T, ? extends @NonNull R> mapper)	Returns a Maybe that applies a specified function to the item emitted by the current Maybe and emits the result of this function application.
final <@NonNull R> @NonNull Maybe<R>	mapOptional(@NonNull Function<? super T, @NonNull Optional<? extends @NonNull R>> mapper)	Maps the upstream success value into an Optional and emits the contained item if not empty.
final @NonNull Single<Notification<T>>	materialize()	Maps the signal types of this Maybe into a Notification of the same kind and emits it as a Single's onSuccess value to downstream.
static <@NonNull T> @NonNull Maybe<T>	merge(@NonNull MaybeSource<? extends MaybeSource<? extends @NonNull T>> source)	Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item emitted by the nested MaybeSource, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Flattens two MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Flattens three MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Flattens four MaybeSources into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Merges a Flow.Publisher sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	merge(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Merges a Flow.Publisher sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	mergeArray(MaybeSource<? extends @NonNull T>... sources)	Merges an array of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.
static <@NonNull T> @NonNull Flowable<T>	mergeArrayDelayError(@NonNull MaybeSource<? extends @NonNull T>... sources)	Flattens an array of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Flattens two MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3)	Flattens three MaybeSource into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull MaybeSource<? extends @NonNull T> source3, @NonNull MaybeSource<? extends @NonNull T> source4)	Flattens four MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Flattens an Iterable sequence of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Flattens a Flow.Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher.
static <@NonNull T> @NonNull Flowable<T>	mergeDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, int maxConcurrency)	Flattens a Flow.Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources.
final @NonNull Flowable<T>	mergeWith(@NonNull MaybeSource<? extends T> other)	Flattens this Maybe and another MaybeSource into a single Flowable, without any transformation.
static <@NonNull T> @NonNull Maybe<T>	never()	Returns a Maybe that never sends any items or notifications to a MaybeObserver.
final @NonNull Maybe<T>	observeOn(@NonNull Scheduler scheduler)	Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
final <@NonNull U> @NonNull Maybe<U>	ofType(@NonNull Class<@NonNull U> clazz)	Filters the items emitted by the current Maybe, only emitting its success value if that is an instance of the supplied Class.
final @NonNull Maybe<T>	onErrorComplete()	Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.
final @NonNull Maybe<T>	onErrorComplete(@NonNull Predicate<? super Throwable> predicate)	Returns a Maybe instance that if this Maybe emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
final @NonNull Maybe<T>	onErrorResumeNext(@NonNull Function<? super Throwable, ? extends MaybeSource<? extends T>> fallbackSupplier)	Resumes the flow with a MaybeSource returned for the failure Throwable of the current Maybe by a function instead of signaling the error via onError.
final @NonNull Maybe<T>	onErrorResumeWith(@NonNull MaybeSource<? extends T> fallback)	Resumes the flow with the given MaybeSource when the current Maybe fails instead of signaling the error via onError.
final @NonNull Maybe<T>	onErrorReturn(@NonNull Function<? super Throwable, ? extends T> itemSupplier)	Ends the flow with a success item returned by a function for the Throwable error signaled by the current Maybe instead of signaling the error via onError.
final @NonNull Maybe<T>	onErrorReturnItem(T item)	Ends the flow with the given success item when the current Maybe fails instead of signaling the error via onError.
final @NonNull Maybe<T>	onTerminateDetach()	Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().
final @NonNull Flowable<T>	repeat()	Returns a Flowable that repeats the sequence of items emitted by the current Maybe indefinitely.
final @NonNull Flowable<T>	repeat(long times)	Returns a Flowable that repeats the sequence of items emitted by the current Maybe at most count times.
final @NonNull Flowable<T>	repeatUntil(@NonNull BooleanSupplier stop)	Returns a Flowable that repeats the sequence of items emitted by the current Maybe until the provided stop function returns true.
final @NonNull Flowable<T>	repeatWhen(@NonNull Function<? super Flowable<Object>, @NonNull ? extends Flow.Publisher<@NonNull ?>> handler)	Returns a Flowable that emits the same values as the current Maybe with the exception of an onComplete.
final @NonNull Maybe<T>	retry()	Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError (infinite retry count).
final @NonNull Maybe<T>	retry(long times)	Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError up to a specified number of retries.
final @NonNull Maybe<T>	retry(long times, @NonNull Predicate<? super Throwable> predicate)	Retries at most times or until the predicate returns false, whichever happens first.
final @NonNull Maybe<T>	retry(@NonNull BiPredicate<? super Integer, ? super Throwable> predicate)	Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.
final @NonNull Maybe<T>	retry(@NonNull Predicate<? super Throwable> predicate)	Retries the current Maybe if it fails and the predicate returns true.
final @NonNull Maybe<T>	retryUntil(@NonNull BooleanSupplier stop)	Retries until the given stop function returns true.
final @NonNull Maybe<T>	retryWhen(@NonNull Function<? super Flowable<Throwable>, @NonNull ? extends Flow.Publisher<@NonNull ?>> handler)	Returns a Maybe that emits the same values as the current Maybe with the exception of an onError.
final void	safeSubscribe(@NonNull MaybeObserver<? super 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).
static <@NonNull T> @NonNull Single<Boolean>	sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2)	Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the same by comparing the items emitted by each MaybeSource pairwise.
static <@NonNull T> @NonNull Single<Boolean>	sequenceEqual(@NonNull MaybeSource<? extends @NonNull T> source1, @NonNull MaybeSource<? extends @NonNull T> source2, @NonNull BiPredicate<? super @NonNull T, ? super @NonNull T> isEqual)	Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified equality function.
final @NonNull Flowable<T>	startWith(@NonNull CompletableSource other)	Returns a Flowable which first runs the other CompletableSource then the current Maybe if the other completed normally.
final @NonNull Flowable<T>	startWith(@NonNull MaybeSource<T> other)	Returns a Flowable which first runs the other MaybeSource then the current Maybe if the other succeeded or completed normally.
final @NonNull Observable<T>	startWith(@NonNull ObservableSource<T> other)	Returns an Observable which first delivers the events of the other ObservableSource then runs the current Maybe.
final @NonNull Flowable<T>	startWith(@NonNull SingleSource<T> other)	Returns a Flowable which first runs the other SingleSource then the current Maybe if the other succeeded normally.
final @NonNull Flowable<T>	startWith(@NonNull Flow.Publisher<T> other)	Returns a Flowable which first delivers the events of the other Flow.Publisher then runs the current Maybe.
final @NonNull Disposable	subscribe()	Subscribes to a Maybe and ignores onSuccess and onComplete emissions.
final void	subscribe(@NonNull MaybeObserver<? super T> observer)	Subscribes the given MaybeObserver to this MaybeSource instance.
final @NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess)	Subscribes to a Maybe and provides a callback to handle the items it emits.
final @NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError)	Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
final @NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete)	Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
final @NonNull Disposable	subscribe(@NonNull Consumer<? super T> onSuccess, @NonNull Consumer<? super Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	Wraps the given onXXX callbacks into a Disposable MaybeObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the MaybeObserver is removed from the given composite.
final @NonNull Maybe<T>	subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.
final <@NonNull E extends MaybeObserver<? super @NonNull T>> E	subscribeWith(@NonNull E observer)	Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.
final @NonNull Maybe<T>	switchIfEmpty(@NonNull MaybeSource<? extends T> other)	Returns a Maybe that emits the items emitted by the current Maybe or the items of an alternate MaybeSource if the current Maybe is empty.
final @NonNull Single<T>	switchIfEmpty(@NonNull SingleSource<? extends T> other)	Returns a Single that emits the items emitted by the current Maybe or the item of an alternate SingleSource if the current Maybe is empty.
static <@NonNull T> @NonNull Flowable<T>	switchOnNext(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Switches between MaybeSources emitted by the source Flow.Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence.
static <@NonNull T> @NonNull Flowable<T>	switchOnNextDelayError(@NonNull Flow.Publisher<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources)	Switches between MaybeSources emitted by the source Flow.Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.
final <@NonNull U> @NonNull Maybe<T>	takeUntil(@NonNull MaybeSource<@NonNull U> other)	Returns a Maybe that emits the items emitted by the current Maybe until a second MaybeSource emits an item.
final <@NonNull U> @NonNull Maybe<T>	takeUntil(@NonNull Flow.Publisher<@NonNull U> other)	Returns a Maybe that emits the item emitted by the current Maybe until a second Flow.Publisher emits an item.
final @NonNull TestObserver<T>	test()	Creates a TestObserver and subscribes it to this Maybe.
final @NonNull TestObserver<T>	test(boolean dispose)	Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
final @NonNull Maybe<Timed<T>>	timeInterval()	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	timeInterval(@NonNull TimeUnit unit)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<T>	timeout(long timeout, @NonNull TimeUnit unit)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item.
final @NonNull Maybe<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull MaybeSource<? extends T> fallback)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item.
final @NonNull Maybe<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
final @NonNull Maybe<T>	timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends T> fallback)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item using a specified Scheduler.
final <@NonNull U> @NonNull Maybe<T>	timeout(@NonNull MaybeSource<@NonNull U> timeoutIndicator)	If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, a TimeoutException is signaled instead.
final <@NonNull U> @NonNull Maybe<T>	timeout(@NonNull MaybeSource<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends T> fallback)	If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, the current Maybe is disposed and the fallback MaybeSource subscribed to as a continuation.
final <@NonNull U> @NonNull Maybe<T>	timeout(@NonNull Flow.Publisher<@NonNull U> timeoutIndicator)	If the current Maybe source didn't signal an event before the timeoutIndicator Flow.Publisher signals, a TimeoutException is signaled instead.
final <@NonNull U> @NonNull Maybe<T>	timeout(@NonNull Flow.Publisher<@NonNull U> timeoutIndicator, @NonNull MaybeSource<? extends T> fallback)	If the current Maybe didn't signal an event before the timeoutIndicator Flow.Publisher signals, the current Maybe is disposed and the fallback MaybeSource subscribed to as a continuation.
static @NonNull Maybe<Long>	timer(long delay, @NonNull TimeUnit unit)	Returns a Maybe that emits 0L after a specified delay.
static @NonNull Maybe<Long>	timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.
final @NonNull Maybe<Timed<T>>	timestamp()	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	timestamp(@NonNull TimeUnit unit)	Combines the success value from the current Maybe with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.
final @NonNull Maybe<Timed<T>>	timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
final <R> R	to(@NonNull MaybeConverter<T, ? extends R> converter)	Calls the specified converter function during assembly time and returns its resulting value.
final @NonNull CompletionStage<T>	toCompletionStage()	Signals the upstream success item (or a NoSuchElementException if the upstream is empty) via a CompletionStage.
final @NonNull CompletionStage<T>	toCompletionStage(T defaultItem)	Signals the upstream success item (or the default item if the upstream is empty) via a CompletionStage.
final @NonNull Flowable<T>	toFlowable()	Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.
final @NonNull Future<T>	toFuture()	Returns a Future representing the single value emitted by the current Maybe or null if the current Maybe is empty.
final @NonNull Observable<T>	toObservable()	Converts this Maybe into an Observable instance composing disposal through.
final @NonNull Single<T>	toSingle()	Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a signal of NoSuchElementException.
static <@NonNull T> @NonNull Maybe<T>	unsafeCreate(@NonNull MaybeSource<@NonNull T> onSubscribe)	Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.
final @NonNull Maybe<T>	unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified Scheduler.
static <@NonNull T, @NonNull D> @NonNull Maybe<T>	using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs a Maybe that creates a dependent resource object which is disposed of when the generated MaybeSource terminates or the downstream calls dispose().
static <@NonNull T, @NonNull D> @NonNull Maybe<T>	using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D, ? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	Constructs a Maybe that creates a dependent resource object which is disposed first ({code eager == true}) when the generated MaybeSource terminates or the downstream disposes; or after ({code eager == false}).
static <@NonNull T> @NonNull Maybe<T>	wrap(@NonNull MaybeSource<@NonNull T> source)	Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull T9, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull MaybeSource<? extends @NonNull T9> source9, @NonNull Function9<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? super @NonNull T8, ? super @NonNull T9, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull T8, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull MaybeSource<? extends @NonNull T8> source8, @NonNull Function8<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? super @NonNull T8, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull T7, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull MaybeSource<? extends @NonNull T7> source7, @NonNull Function7<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? super @NonNull T7, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull T6, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull MaybeSource<? extends @NonNull T6> source6, @NonNull Function6<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? super @NonNull T6, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull T5, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull MaybeSource<? extends @NonNull T5> source5, @NonNull Function5<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? super @NonNull T5, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull T4, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull MaybeSource<? extends @NonNull T4> source4, @NonNull Function4<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? super @NonNull T4, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull T3, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull MaybeSource<? extends @NonNull T3> source3, @NonNull Function3<? super @NonNull T1, ? super @NonNull T2, ? super @NonNull T3, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other MaybeSources.
static <@NonNull T1, @NonNull T2, @NonNull R> @NonNull Maybe<R>	zip(@NonNull MaybeSource<? extends @NonNull T1> source1, @NonNull MaybeSource<? extends @NonNull T2> source2, @NonNull BiFunction<? super @NonNull T1, ? super @NonNull T2, ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other MaybeSources.
static <@NonNull T, @NonNull R> @NonNull Maybe<R>	zip(@NonNull Iterable<@NonNull ? extends MaybeSource<? extends @NonNull T>> sources, @NonNull Function<? super Object[], ? extends @NonNull R> zipper)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other MaybeSources.
static <@NonNull T, @NonNull R> @NonNull Maybe<R>	zipArray(@NonNull Function<? super Object[], ? extends @NonNull R> zipper, @NonNull MaybeSource<? extends @NonNull T>... sources)	Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other MaybeSources.
final <@NonNull U, @NonNull R> @NonNull Maybe<R>	zipWith(@NonNull MaybeSource<? extends @NonNull U> other, @NonNull BiFunction<? super T, ? super @NonNull U, ? extends @NonNull R> zipper)	Waits until this and the other MaybeSource signal a success value then applies the given BiFunction to those values and emits the BiFunction's resulting value to downstream.

Methods inherited from class Object

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

Method Details

create

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

Creates a fresh MaybeSubject.

Type Parameters:

T - the value type received and emitted

Returns:

the new MaybeSubject instance

onSubscribe

public void onSubscribe(Disposable d)

Description copied from interface: MaybeObserver

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

Specified by:

onSubscribe in interface MaybeObserver<T>

Parameters:

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

onSuccess

public void onSuccess(T value)

Description copied from interface: MaybeObserver

Notifies the MaybeObserver with one item and that the Maybe has finished sending push-based notifications.

The Maybe will not call this method if it calls MaybeObserver.onError(Throwable).

Specified by:

onSuccess in interface MaybeObserver<T>

Parameters:

value - the item emitted by the Maybe

onError

public void onError(Throwable e)

Description copied from interface: MaybeObserver

Notifies the MaybeObserver that the Maybe has experienced an error condition.

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

Specified by:

onError in interface MaybeObserver<T>

Parameters:

e - the exception encountered by the Maybe

onComplete

public void onComplete()

Description copied from interface: MaybeObserver

Called once the deferred computation completes normally.

Specified by:

onComplete in interface MaybeObserver<T>

subscribeActual

protected void subscribeActual(MaybeObserver<? super T> observer)

Description copied from class: Maybe

Implement this method in subclasses to handle the incoming MaybeObservers.

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

Specified by:

subscribeActual in class Maybe<T>

Parameters:

observer - the MaybeObserver to handle, not null

getValue

@Nullable
public T getValue()

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

Returns:

the success value or null

hasValue

public boolean hasValue()

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

Returns:

true if this MaybeSubject was terminated with a success value

getThrowable

@Nullable
public @Nullable Throwable getThrowable()

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

Returns:

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

hasThrowable

public boolean hasThrowable()

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

Returns:

true if this MaybeSubject has been terminated with an error

hasComplete

public boolean hasComplete()

Returns true if this MaybeSubject has been completed.

Returns:

true if this MaybeSubject has been completed

hasObservers

public boolean hasObservers()

Returns true if this MaybeSubject has observers.

Returns:

true if this MaybeSubject has observers