T - the value typepublic abstract class Maybe<T> extends java.lang.Object implements MaybeSource<T>
The main consumer type of Maybe is MaybeObserver whose methods are called
in a sequential fashion following this protocol:
onSubscribe (onSuccess | onError | onComplete)?.
| Constructor and Description |
|---|
Maybe() |
| Modifier and Type | Method and Description |
|---|---|
static <T> Maybe<T> |
amb(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
Runs multiple Maybe sources and signals the events of the first one that signals (cancelling
the rest).
|
static <T> Maybe<T> |
ambArray(MaybeSource<? extends T>... sources)
Runs multiple Maybe sources and signals the events of the first one that signals (cancelling
the rest).
|
Maybe<T> |
ambWith(MaybeSource<? extends T> other)
Mirrors the MaybeSource (current or provided) that first signals an event.
|
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).
|
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).
|
Maybe<T> |
cache()
Returns a Maybe that subscribes to this Maybe lazily, caches its event
and replays it, to all the downstream subscribers.
|
<U> Maybe<U> |
cast(java.lang.Class<? extends U> clazz)
Casts the success value of the current Maybe into the target type or signals a
ClassCastException if not compatible.
|
<R> Maybe<R> |
compose(MaybeTransformer<? super T,? extends R> transformer)
Transform a Maybe by applying a particular Transformer function to it.
|
static <T> Observable<T> |
concat(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by
an Iterable sequence.
|
static <T> Observable<T> |
concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Returns an Observable that emits the items emitted by two MaybeSources, one after the other.
|
static <T> Observable<T> |
concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Returns an Observable that emits the items emitted by three MaybeSources, one after the other.
|
static <T> Observable<T> |
concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Returns an Observable that emits the items emitted by four MaybeSources, one after the other.
|
static <T> Observable<T> |
concat(ObservableSource<? extends MaybeSource<? extends T>> sources)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by
an ObservableSource sequence.
|
static <T> Observable<T> |
concat(ObservableSource<? extends MaybeSource<? extends T>> sources,
int prefetch)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by
an ObservableSource sequence.
|
static <T> Observable<T> |
concatArray(MaybeSource<? extends T>... sources)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
|
static <T> Observable<T> |
concatArrayDelayError(MaybeSource<? extends T>... sources)
Concatenates a variable number of MaybeSource sources and delays errors from any of them
till all terminate.
|
static <T> Observable<T> |
concatArrayEager(MaybeSource<? extends T>... sources)
Concatenates a sequence of MaybeSource eagerly into a single stream of values.
|
static <T> Observable<T> |
concatDelayError(java.lang.Iterable<? extends MaybeSource<? extends 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.
|
static <T> Observable<T> |
concatDelayError(ObservableSource<? extends MaybeSource<? extends T>> sources)
Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource,
one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
|
static <T> Observable<T> |
concatEager(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
Concatenates a sequence of MaybeSources eagerly into a single stream of values.
|
static <T> Observable<T> |
concatEager(ObservableSource<? extends MaybeSource<? extends T>> sources)
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
|
<R> Maybe<R> |
concatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends R>> mapper)
Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe,
where that function returns a MaybeSource.
|
Observable<T> |
concatWith(MaybeSource<? extends T> other)
Returns an Observable that emits the items emitted from the current MaybeSource, then the next, one after
the other, without interleaving them.
|
Single<java.lang.Boolean> |
contains(java.lang.Object item)
Returns a Single that emits a Boolean that indicates whether the source Maybe emitted a
specified item.
|
Single<java.lang.Long> |
count()
Returns a Maybe that counts the total number of items emitted (0 or 1) by the source Maybe and emits
this count as a 64-bit Long.
|
static <T> Maybe<T> |
create(MaybeOnSubscribe<T> onSubscribe)
Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
|
Maybe<T> |
defaultIfEmpty(T defaultItem)
Returns a Maybe that emits the item emitted by the source Maybe or a specified default item
if the source Maybe is empty.
|
static <T> Maybe<T> |
defer(java.util.concurrent.Callable<? extends MaybeSource<? extends T>> maybeSupplier)
Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to
be subscribed to.
|
Maybe<T> |
delay(long delay,
java.util.concurrent.TimeUnit unit)
Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a
specified delay.
|
Maybe<T> |
delay(long delay,
java.util.concurrent.TimeUnit unit,
io.reactivex.common.Scheduler scheduler)
Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a
specified delay running on the specified Scheduler.
|
<U,V> Maybe<T> |
delay(ObservableSource<U> delayIndicator)
Delays the emission of this Maybe until the given ObservableSource signals an item or completes.
|
Maybe<T> |
delaySubscription(long delay,
java.util.concurrent.TimeUnit unit)
Returns a Maybe that delays the subscription to the source Maybe by a given amount of time.
|
Maybe<T> |
delaySubscription(long delay,
java.util.concurrent.TimeUnit unit,
io.reactivex.common.Scheduler scheduler)
Returns a Maybe that delays the subscription to the source Maybe by a given amount of time,
both waiting and subscribing on a given Scheduler.
|
<U> Maybe<T> |
delaySubscription(ObservableSource<U> subscriptionIndicator)
Returns a Maybe that delays the subscription to this Maybe
until the other ObservableSource emits an element or completes normally.
|
Maybe<T> |
doAfterSuccess(io.reactivex.common.functions.Consumer<? super T> onAfterSuccess)
Calls the specified consumer with the success item after this item has been emitted to the downstream.
|
Maybe<T> |
doAfterTerminate(io.reactivex.common.functions.Action onAfterTerminate)
|
Maybe<T> |
doFinally(io.reactivex.common.functions.Action onFinally)
Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by
the downstream.
|
Maybe<T> |
doOnComplete(io.reactivex.common.functions.Action onComplete)
Modifies the source Maybe so that it invokes an action when it calls
onComplete. |
Maybe<T> |
doOnDispose(io.reactivex.common.functions.Action onDispose)
Calls the shared runnable if a MaybeObserver subscribed to the current Maybe
disposes the common Disposable it received via onSubscribe.
|
Maybe<T> |
doOnError(io.reactivex.common.functions.Consumer<? super java.lang.Throwable> onError)
Calls the shared consumer with the error sent via onError for each
MaybeObserver that subscribes to the current Maybe.
|
Maybe<T> |
doOnEvent(io.reactivex.common.functions.BiConsumer<? super T,? super java.lang.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.
|
Maybe<T> |
doOnSubscribe(io.reactivex.common.functions.Consumer<? super io.reactivex.common.Disposable> onSubscribe)
Calls the shared consumer with the Disposable sent through the onSubscribe for each
MaybeObserver that subscribes to the current Maybe.
|
Maybe<T> |
doOnSuccess(io.reactivex.common.functions.Consumer<? super T> onSuccess)
Calls the shared consumer with the success value sent via onSuccess for each
MaybeObserver that subscribes to the current Maybe.
|
static <T> Maybe<T> |
empty()
Returns a (singleton) Maybe instance that calls
onComplete
immediately. |
static <T> Maybe<T> |
error(java.util.concurrent.Callable<? extends java.lang.Throwable> supplier)
Returns a Maybe that invokes a
MaybeObserver's onError method when the
MaybeObserver subscribes to it. |
static <T> Maybe<T> |
error(java.lang.Throwable exception)
Returns a Maybe that invokes a subscriber's
onError method when the
subscriber subscribes to it. |
Maybe<T> |
filter(io.reactivex.common.functions.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.
|
<R> Maybe<R> |
flatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends R>> mapper)
Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe,
where that function returns a MaybeSource.
|
<R> Maybe<R> |
flatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
io.reactivex.common.functions.Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
java.util.concurrent.Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that
MaybeSource's signals
Scheduler:
flatMap does not operate by default on a particular Scheduler. |
<U,R> Maybe<R> |
flatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends U>> mapper,
io.reactivex.common.functions.BiFunction<? super T,? super U,? extends R> resultSelector)
Returns a Maybe that emits the results of a specified function to the pair of values emitted by the
source Maybe and a specified mapped MaybeSource.
|
Completable |
flatMapCompletable(io.reactivex.common.functions.Function<? super T,? extends CompletableSource> mapper)
Returns a
Completable that completes based on applying a specified function to the item emitted by the
source Maybe, where that function returns a Completable. |
<R> Observable<R> |
flatMapObservable(io.reactivex.common.functions.Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns an Observable that is based on applying a specified function to the item emitted by the source Maybe,
where that function returns an ObservableSource.
|
<R> Single<R> |
flatMapSingle(io.reactivex.common.functions.Function<? super T,? extends SingleSource<? extends R>> mapper)
|
<R> Maybe<R> |
flatMapSingleElement(io.reactivex.common.functions.Function<? super T,? extends SingleSource<? extends R>> mapper)
|
<U> Observable<U> |
flattenAsObservable(io.reactivex.common.functions.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
Returns an Observable that maps a success value into an Iterable and emits its items.
|
static <T> Maybe<T> |
fromAction(io.reactivex.common.functions.Action run)
Returns a Maybe instance that runs the given Action for each subscriber and
emits either its exception or simply completes.
|
static <T> Maybe<T> |
fromCallable(java.util.concurrent.Callable<? extends T> callable)
Returns a
Maybe that invokes passed function and emits its result for each new MaybeObserver that subscribes
while considering null value from the callable as indication for valueless completion. |
static <T> Maybe<T> |
fromCompletable(CompletableSource completableSource)
Wraps a CompletableSource into a Maybe.
|
static <T> Maybe<T> |
fromFuture(java.util.concurrent.Future<? extends T> future)
Converts a
Future into a Maybe, treating a null result as an indication of emptiness. |
static <T> Maybe<T> |
fromFuture(java.util.concurrent.Future<? extends T> future,
long timeout,
java.util.concurrent.TimeUnit unit)
Converts a
Future into a Maybe, with a timeout on the Future. |
static <T> Maybe<T> |
fromRunnable(java.lang.Runnable run)
Returns a Maybe instance that runs the given Action for each subscriber and
emits either its exception or simply completes.
|
static <T> Maybe<T> |
fromSingle(SingleSource<T> singleSource)
Wraps a SingleSource into a Maybe.
|
Maybe<T> |
hide()
Hides the identity of this Maybe and its Disposable.
|
Completable |
ignoreElement()
Ignores the item emitted by the source Maybe and only calls
onComplete or onError. |
Single<java.lang.Boolean> |
isEmpty()
Returns a Single that emits
true if the source Maybe is empty, otherwise false. |
static <T> Maybe<T> |
just(T item)
Returns a
Maybe that emits a specified item. |
<R> Maybe<R> |
lift(MaybeOperator<? extends R,? super T> lift)
Lifts a function to the current Maybe and returns a new Maybe that when subscribed to will pass the
values of the current Maybe through the MaybeOperator function.
|
<R> Maybe<R> |
map(io.reactivex.common.functions.Function<? super T,? extends R> mapper)
Returns a Maybe that applies a specified function to the item emitted by the source Maybe and
emits the result of this function application.
|
static <T> Observable<T> |
merge(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
Merges an Iterable sequence of MaybeSource instances into a single Observable sequence,
running all MaybeSources at once.
|
static <T> Maybe<T> |
merge(MaybeSource<? extends MaybeSource<? extends 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 <T> Observable<T> |
merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSources into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into a single Observable, without any transformation.
|
static <T> Observable<T> |
merge(ObservableSource<? extends MaybeSource<? extends T>> sources)
Merges an Observable sequence of MaybeSource instances into a single Observable sequence,
running all MaybeSources at once.
|
static <T> Observable<T> |
merge(ObservableSource<? extends MaybeSource<? extends T>> sources,
int maxConcurrency)
Merges an Observable sequence of MaybeSource instances into a single Observable sequence,
running at most maxConcurrency MaybeSources at once.
|
static <T> Observable<T> |
mergeArray(MaybeSource<? extends T>... sources)
Merges an array sequence of MaybeSource instances into a single Observable sequence,
running all MaybeSources at once.
|
static <T> Observable<T> |
mergeArrayDelayError(MaybeSource<? extends T>... sources)
Flattens an array of MaybeSources into one Observable, in a way that allows an Observer to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
mergeDelayError(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
Flattens an Iterable of MaybeSources into one Observable, in a way that allows an Observer to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into one Observable, in a way that allows an Observer to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSource into one Observable, in a way that allows an Observer to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into one Observable, in a way that allows an Observer to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
mergeDelayError(ObservableSource<? extends MaybeSource<? extends T>> sources)
Flattens an ObservableSource that emits MaybeSources into one ObservableSource, in a way that allows an Observer to
receive all successfully emitted items from all of the source ObservableSources without being interrupted by
an error notification from one of them.
|
Observable<T> |
mergeWith(MaybeSource<? extends T> other)
Flattens this and another Maybe into a single Observable, without any transformation.
|
static <T> Maybe<T> |
never()
Returns a Maybe that never sends any items or notifications to a
MaybeObserver. |
Maybe<T> |
observeOn(io.reactivex.common.Scheduler scheduler)
Wraps a Maybe to emit its item (or notify of its error) on a specified
Scheduler,
asynchronously. |
<U> Maybe<U> |
ofType(java.lang.Class<U> clazz)
Filters the items emitted by a Maybe, only emitting its success value if that
is an instance of the supplied Class.
|
Maybe<T> |
onErrorComplete()
Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete
and swallow the throwable.
|
Maybe<T> |
onErrorComplete(io.reactivex.common.functions.Predicate<? super java.lang.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.
|
Maybe<T> |
onErrorResumeNext(io.reactivex.common.functions.Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>> resumeFunction)
Instructs a Maybe to pass control to another Maybe rather than invoking
onError if it encounters an error. |
Maybe<T> |
onErrorResumeNext(MaybeSource<? extends T> next)
Instructs a Maybe to pass control to another MaybeSource rather than invoking
onError if it encounters an error. |
Maybe<T> |
onErrorReturn(io.reactivex.common.functions.Function<? super java.lang.Throwable,? extends T> valueSupplier)
Instructs a Maybe to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Maybe<T> |
onErrorReturnItem(T item)
Instructs a Maybe to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Maybe<T> |
onExceptionResumeNext(MaybeSource<? extends T> next)
Instructs a Maybe to pass control to another MaybeSource rather than invoking
onError if it encounters an Exception. |
Maybe<T> |
onTerminateDetach()
Nulls out references to the upstream producer and downstream MaybeObserver if
the sequence is terminated or downstream calls dispose().
|
Observable<T> |
repeat()
Returns an Observable that repeats the sequence of items emitted by the source Maybe indefinitely.
|
Observable<T> |
repeat(long times)
Returns an Observable that repeats the sequence of items emitted by the source Maybe at most
count times. |
Observable<T> |
repeatUntil(io.reactivex.common.functions.BooleanSupplier stop)
Returns an Observable that repeats the sequence of items emitted by the source Maybe until
the provided stop function returns true.
|
Observable<T> |
repeatWhen(io.reactivex.common.functions.Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>> handler)
Returns an Observable that emits the same values as the source ObservableSource with the exception of an
onComplete. |
Maybe<T> |
retry()
Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls
onError
(infinite retry count). |
Maybe<T> |
retry(io.reactivex.common.functions.BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)
Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls
onError
and the predicate returns true for that specific exception and retry count. |
Maybe<T> |
retry(long count)
Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls
onError
up to a specified number of retries. |
Maybe<T> |
retry(long times,
io.reactivex.common.functions.Predicate<? super java.lang.Throwable> predicate)
Retries at most times or until the predicate returns false, whichever happens first.
|
Maybe<T> |
retry(io.reactivex.common.functions.Predicate<? super java.lang.Throwable> predicate)
Retries the current Maybe if it fails and the predicate returns true.
|
Maybe<T> |
retryUntil(io.reactivex.common.functions.BooleanSupplier stop)
Retries until the given stop function returns true.
|
Maybe<T> |
retryWhen(io.reactivex.common.functions.Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>> handler)
Returns a Maybe that emits the same values as the source Maybe with the exception of an
onError. |
static <T> Single<java.lang.Boolean> |
sequenceEqual(MaybeSource<? extends T> source1,
MaybeSource<? extends 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 <T> Single<java.lang.Boolean> |
sequenceEqual(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
io.reactivex.common.functions.BiPredicate<? super T,? super 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.
|
io.reactivex.common.Disposable |
subscribe()
Subscribes to a Maybe and ignores
onSuccess and onComplete emissions. |
io.reactivex.common.Disposable |
subscribe(io.reactivex.common.functions.Consumer<? super T> onSuccess)
Subscribes to a Maybe and provides a callback to handle the items it emits.
|
io.reactivex.common.Disposable |
subscribe(io.reactivex.common.functions.Consumer<? super T> onSuccess,
io.reactivex.common.functions.Consumer<? super java.lang.Throwable> onError)
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error
notification it issues.
|
io.reactivex.common.Disposable |
subscribe(io.reactivex.common.functions.Consumer<? super T> onSuccess,
io.reactivex.common.functions.Consumer<? super java.lang.Throwable> onError,
io.reactivex.common.functions.Action onComplete)
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
void |
subscribe(MaybeObserver<? super T> observer)
Subscribes the given MaybeObserver to this MaybeSource instance.
|
protected abstract void |
subscribeActual(MaybeObserver<? super T> observer)
Override this method in subclasses to handle the incoming MaybeObservers.
|
Maybe<T> |
subscribeOn(io.reactivex.common.Scheduler scheduler)
Asynchronously subscribes subscribers to this Maybe on the specified
Scheduler. |
<E extends MaybeObserver<? super T>> |
subscribeWith(E observer)
Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given
MaybeObserver as is.
|
Maybe<T> |
switchIfEmpty(MaybeSource<? extends T> other)
Returns a Maybe that emits the items emitted by the source Maybe or the items of an alternate
MaybeSource if the current Maybe is empty.
|
<U> Maybe<T> |
takeUntil(MaybeSource<U> other)
Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource
emits an item.
|
<U> Maybe<T> |
takeUntil(ObservableSource<U> other)
Returns a Maybe that emits the item emitted by the source Maybe until a second ObservableSource
emits an item.
|
TestObserver<T> |
test()
Creates a TestObserver and subscribes
it to this Maybe.
|
TestObserver<T> |
test(boolean cancelled)
Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
|
Maybe<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item.
|
Maybe<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
MaybeSource<? extends T> fallback)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item.
|
Maybe<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
io.reactivex.common.Scheduler scheduler)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item, where this policy is governed on a specified Scheduler.
|
Maybe<T> |
timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
io.reactivex.common.Scheduler scheduler,
MaybeSource<? extends T> fallback)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item using a specified Scheduler.
|
<U> Maybe<T> |
timeout(MaybeSource<U> timeoutIndicator)
If this Maybe source didn't signal an event before the timeoutIndicator MaybeSource signals, a
TimeoutException is signalled instead.
|
<U> Maybe<T> |
timeout(MaybeSource<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current Maybe source didn't signal an event before the timeoutIndicator MaybeSource signals,
the current Maybe is cancelled and the
fallback MaybeSource subscribed to
as a continuation. |
<U> Maybe<T> |
timeout(ObservableSource<U> timeoutIndicator)
If this Maybe source didn't signal an event before the timeoutIndicator ObservableSource signals, a
TimeoutException is signalled instead.
|
<U> Maybe<T> |
timeout(ObservableSource<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current Maybe source didn't signal an event before the timeoutIndicator ObservableSource signals,
the current Maybe is cancelled and the
fallback MaybeSource subscribed to
as a continuation. |
static Maybe<java.lang.Long> |
timer(long delay,
java.util.concurrent.TimeUnit unit)
Returns a Maybe that emits
0L after a specified delay. |
static Maybe<java.lang.Long> |
timer(long delay,
java.util.concurrent.TimeUnit unit,
io.reactivex.common.Scheduler scheduler)
Returns a Maybe that emits
0L after a specified delay on a specified Scheduler. |
<R> R |
to(io.reactivex.common.functions.Function<? super Maybe<T>,R> convert)
Calls the specified converter function with the current Maybe instance
during assembly time and returns its result.
|
Observable<T> |
toObservable()
Converts this Maybe into an Observable instance composing cancellation
through.
|
Single<T> |
toSingle()
Converts this Maybe into a Single instance composing cancellation
through and turning an empty Maybe into a signal of NoSuchElementException.
|
Single<T> |
toSingle(T defaultValue)
Converts this Maybe into a Single instance composing cancellation
through and turning an empty Maybe into a signal of NoSuchElementException.
|
static <T> Maybe<T> |
unsafeCreate(MaybeSource<T> onSubscribe)
Advanced use only: creates a Maybe instance without
any safeguards by using a callback that is called with a MaybeObserver.
|
Maybe<T> |
unsubscribeOn(io.reactivex.common.Scheduler scheduler)
Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable,
that call is propagated up on the specified scheduler
Scheduler:
unsubscribeOn calls dispose() of the upstream on the Scheduler you specify. |
static <T,D> Maybe<T> |
using(java.util.concurrent.Callable<? extends D> resourceSupplier,
io.reactivex.common.functions.Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
io.reactivex.common.functions.Consumer<? super D> resourceDisposer)
Constructs a Maybe that creates a dependent resource object which is disposed of when the
upstream terminates or the downstream calls dispose().
|
static <T,D> Maybe<T> |
using(java.util.concurrent.Callable<? extends D> resourceSupplier,
io.reactivex.common.functions.Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
io.reactivex.common.functions.Consumer<? super D> resourceDisposer,
boolean eager)
Constructs a Maybe that creates a dependent resource object which is disposed of just before
termination if you have set
disposeEagerly to true and a downstream dispose() does not occur
before termination. |
static <T> Maybe<T> |
wrap(MaybeSource<T> source)
Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe
instance.
|
static <T,R> Maybe<R> |
zip(java.lang.Iterable<? extends MaybeSource<? extends T>> sources,
io.reactivex.common.functions.Function<? super java.lang.Object[],? extends 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 <T1,T2,R> Maybe<R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
io.reactivex.common.functions.BiFunction<? super T1,? super T2,? extends 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 <T1,T2,T3,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
io.reactivex.common.functions.Function3<? super T1,? super T2,? super T3,? extends 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 <T1,T2,T3,T4,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
io.reactivex.common.functions.Function4<? super T1,? super T2,? super T3,? super T4,? extends 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 <T1,T2,T3,T4,T5,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
io.reactivex.common.functions.Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends 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 <T1,T2,T3,T4,T5,T6,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
io.reactivex.common.functions.Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends 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 <T1,T2,T3,T4,T5,T6,T7,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
MaybeSource<? extends T7> source7,
io.reactivex.common.functions.Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends 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 <T1,T2,T3,T4,T5,T6,T7,T8,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
MaybeSource<? extends T7> source7,
MaybeSource<? extends T8> source8,
io.reactivex.common.functions.Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends 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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
MaybeSource<? extends T7> source7,
MaybeSource<? extends T8> source8,
MaybeSource<? extends T9> source9,
io.reactivex.common.functions.Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends 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 <T,R> Maybe<R> |
zipArray(io.reactivex.common.functions.Function<? super java.lang.Object[],? extends R> zipper,
MaybeSource<? extends 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.
|
<U,R> Maybe<R> |
zipWith(MaybeSource<? extends U> other,
io.reactivex.common.functions.BiFunction<? super T,? super U,? extends 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.
|
@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> amb(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
amb does not operate by default on a particular Scheduler.T - the value typesources - the Iterable sequence of sources. A subscription to each source will
occur in the same order as in the Iterable.@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> ambArray(MaybeSource<? extends T>... sources)
ambArray does not operate by default on a particular Scheduler.T - the value typesources - the array of sources. A subscription to each source will
occur in the same order as in the array.@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concat(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
concat does not operate by default on a particular Scheduler.T - the value typesources - the Iterable sequence of MaybeSource instances@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concat(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)
concat does not operate by default on a particular Scheduler.T - the common value typesource1 - a MaybeSource to be concatenatedsource2 - a MaybeSource to be concatenated@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concat(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3)
concat does not operate by default on a particular Scheduler.T - the common value typesource1 - a MaybeSource to be concatenatedsource2 - a MaybeSource to be concatenatedsource3 - a MaybeSource to be concatenated@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concat(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3, MaybeSource<? extends T> source4)
concat does not operate by default on a particular Scheduler.T - the common value typesource1 - a MaybeSource to be concatenatedsource2 - a MaybeSource to be concatenatedsource3 - a MaybeSource to be concatenatedsource4 - a MaybeSource to be concatenated@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concat(ObservableSource<? extends MaybeSource<? extends T>> sources)
concat does not operate by default on a particular Scheduler.T - the value typesources - the ObservableSource of MaybeSource instances@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concat(ObservableSource<? extends MaybeSource<? extends T>> sources, int prefetch)
concat does not operate by default on a particular Scheduler.T - the value typesources - the ObservableSource of MaybeSource instancesprefetch - the number of MaybeSources to prefetch from the ObservableSource@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatArray(MaybeSource<? extends T>... sources)
concatArray does not operate by default on a particular Scheduler.T - the value typesources - the array of MaybeSource instances@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatArrayDelayError(MaybeSource<? extends T>... sources)
concatArrayDelayError does not operate by default on a particular Scheduler.T - the common base value typesources - the array of sourcesjava.lang.NullPointerException - if sources is null@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatArrayEager(MaybeSource<? extends T>... sources)
Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source MaybeSources. The operator buffers the value emitted by these MaybeSources and then drains them in order, each one after the previous one completes.
Scheduler.T - the value typesources - a sequence of MaybeSources that need to be eagerly concatenated@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatDelayError(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
concatDelayError does not operate by default on a particular Scheduler.T - the common element base typesources - the Iterable sequence of MaybeSources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatDelayError(ObservableSource<? extends MaybeSource<? extends T>> sources)
concatDelayError does not operate by default on a particular Scheduler.T - the common element base typesources - the ObservableSource sequence of ObservableSources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatEager(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the source MaybeSources. The operator buffers the values emitted by these MaybeSources and then drains them in order, each one after the previous one completes.
Scheduler.T - the value typesources - a sequence of MaybeSource that need to be eagerly concatenated@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> concatEager(ObservableSource<? extends MaybeSource<? extends T>> sources)
Eager concatenation means that once a subscriber subscribes, this operator subscribes to all of the emitted source ObservableSources as they are observed. The operator buffers the values emitted by these ObservableSources and then drains them in order, each one after the previous one completes.
Scheduler.T - the value typesources - a sequence of ObservableSources that need to be eagerly concatenated@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> create(MaybeOnSubscribe<T> onSubscribe)
Example:
Maybe.<Event>create(emitter -> {
Callback listener = new Callback() {
@Override
public void onEvent(Event e) {
if (e.isNothing()) {
emitter.onComplete();
} else {
emitter.onSuccess(e);
}
}
@Override
public void onFailure(Exception e) {
emitter.onError(e);
}
};
AutoCloseable c = api.someMethod(listener);
emitter.setCancellable(c::close);
});
create does not operate by default on a particular Scheduler.T - the value typeonSubscribe - the emitter that is called when a MaybeObserver subscribes to the returned MaybeMaybeOnSubscribe,
Cancellable@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> defer(java.util.concurrent.Callable<? extends MaybeSource<? extends T>> maybeSupplier)
defer does not operate by default on a particular Scheduler.T - the value typemaybeSupplier - the Callable that is called for each individual MaybeObserver and
returns a MaybeSource instance to subscribe to@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> empty()
onComplete
immediately.
empty does not operate by default on a particular Scheduler.T - the value type@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> error(java.lang.Throwable exception)
onError method when the
subscriber subscribes to it.
error does not operate by default on a particular Scheduler.T - the type of the item (ostensibly) emitted by the Maybeexception - the particular Throwable to pass to onErroronError method when
the subscriber subscribes to it@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> error(java.util.concurrent.Callable<? extends java.lang.Throwable> supplier)
MaybeObserver's onError method when the
MaybeObserver subscribes to it.
error does not operate by default on a particular Scheduler.T - the type of the items (ostensibly) emitted by the Maybesupplier - a Callable factory to return a Throwable for each individual MaybeObserverMaybeObserver's onError method when
the MaybeObserver subscribes to it@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromAction(io.reactivex.common.functions.Action run)
fromAction does not operate by default on a particular Scheduler.T - the target typerun - the runnable to run for each subscriberjava.lang.NullPointerException - if run is null@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromCompletable(CompletableSource completableSource)
fromCompletable does not operate by default on a particular Scheduler.T - the target typecompletableSource - the CompletableSource to convert fromjava.lang.NullPointerException - if completable is null@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromSingle(SingleSource<T> singleSource)
fromSingle does not operate by default on a particular Scheduler.T - the target typesingleSource - the SingleSource to convert fromjava.lang.NullPointerException - if single is null@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromCallable(java.util.concurrent.Callable<? extends T> callable)
Maybe that invokes passed function and emits its result for each new MaybeObserver that subscribes
while considering null value from the callable as indication for valueless completion.
Allows you to defer execution of passed function until MaybeObserver subscribes to the Maybe.
It makes passed function "lazy".
Result of the function invocation will be emitted by the Maybe.
fromCallable does not operate by default on a particular Scheduler.T - the type of the item emitted by the Maybe.callable - function which execution should be deferred, it will be invoked when MaybeObserver will subscribe to the Maybe.Maybe whose MaybeObservers' subscriptions trigger an invocation of the given function.@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromFuture(java.util.concurrent.Future<? extends T> future)
Future into a Maybe, treating a null result as an indication of emptiness.
You can convert any object that supports the Future interface into a Maybe that emits the
return value of the Future.get() method of that object, by passing the object into the from
method.
Important note: This Maybe is blocking; you cannot dispose it.
Unlike 1.x, cancelling the Maybe won't cancel the future. If necessary, one can use composition to achieve the
cancellation effect: futureMaybe.doOnDispose(() -> future.cancel(true));.
fromFuture does not operate by default on a particular Scheduler.T - the type of object that the Future returns, and also the type of item to be emitted by
the resulting Maybefuture - the source FutureFuture@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromFuture(java.util.concurrent.Future<? extends T> future, long timeout, java.util.concurrent.TimeUnit unit)
Future into a Maybe, with a timeout on the Future.
You can convert any object that supports the Future interface into a Maybe that emits the
return value of the Future.get() method of that object, by passing the object into the fromFuture
method.
Unlike 1.x, cancelling the Maybe won't cancel the future. If necessary, one can use composition to achieve the
cancellation effect: futureMaybe.doOnCancel(() -> future.cancel(true));.
Important note: This Maybe is blocking on the thread it gets subscribed on; you cannot dispose it.
fromFuture does not operate by default on a particular Scheduler.T - the type of object that the Future returns, and also the type of item to be emitted by
the resulting Maybefuture - the source Futuretimeout - the maximum time to wait before calling getunit - the TimeUnit of the timeout argumentFuture@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> fromRunnable(java.lang.Runnable run)
fromRunnable does not operate by default on a particular Scheduler.T - the target typerun - the runnable to run for each subscriberjava.lang.NullPointerException - if run is null@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> just(T item)
Maybe that emits a specified item.
To convert any object into a Maybe that emits that object, pass that object into the
just method.
just does not operate by default on a particular Scheduler.T - the type of that itemitem - the item to emitMaybe that emits item@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> merge(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
merge does not operate by default on a particular Scheduler.T - the common and resulting value typesources - the Iterable sequence of MaybeSource sources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> merge(ObservableSource<? extends MaybeSource<? extends T>> sources)
merge does not operate by default on a particular Scheduler.T - the common and resulting value typesources - the Observable sequence of MaybeSource sources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> merge(ObservableSource<? extends MaybeSource<? extends T>> sources, int maxConcurrency)
merge does not operate by default on a particular Scheduler.T - the common and resulting value typesources - the Observable sequence of MaybeSource sourcesmaxConcurrency - the maximum number of concurrently running MaybeSources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> merge(MaybeSource<? extends MaybeSource<? extends T>> source)
MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item
emitted by the nested MaybeSource, without any transformation.
merge does not operate by default on a particular Scheduler.T - the value type of the sources and the outputsource - a MaybeSource that emits a MaybeSourceMaybe that emits the item that is the result of flattening the MaybeSource emitted
by source@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> merge(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)
You can combine items emitted by multiple MaybeSources so that they appear as a single Observable, by
using the merge method.
merge does not operate by default on a particular Scheduler.T - the common value typesource1 - a MaybeSource to be mergedsource2 - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> merge(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3)
You can combine items emitted by multiple MaybeSources so that they appear as a single Observable, by using
the merge method.
merge does not operate by default on a particular Scheduler.T - the common value typesource1 - a MaybeSource to be mergedsource2 - a MaybeSource to be mergedsource3 - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> merge(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3, MaybeSource<? extends T> source4)
You can combine items emitted by multiple MaybeSources so that they appear as a single Observable, by using
the merge method.
merge does not operate by default on a particular Scheduler.T - the common value typesource1 - a MaybeSource to be mergedsource2 - a MaybeSource to be mergedsource3 - a MaybeSource to be mergedsource4 - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeArray(MaybeSource<? extends T>... sources)
mergeArray does not operate by default on a particular Scheduler.T - the common and resulting value typesources - the array sequence of MaybeSource sources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeArrayDelayError(MaybeSource<? extends T>... sources)
This behaves like mergeArray(MaybeSource...) except that if any of the merged MaybeSources notify of an
error via onError, mergeDelayError will refrain from propagating that
error notification until all of the merged MaybeSources have finished emitting items.
Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only
invoke the onError method of its Observers once.
mergeArrayDelayError does not operate by default on a particular Scheduler.T - the common element base typesources - the Iterable of MaybeSources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeDelayError(java.lang.Iterable<? extends MaybeSource<? extends T>> sources)
This behaves like merge(Iterable) except that if any of the merged MaybeSources notify of an
error via onError, mergeDelayError will refrain from propagating that
error notification until all of the merged MaybeSources have finished emitting items.
Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only
invoke the onError method of its Observers once.
mergeDelayError does not operate by default on a particular Scheduler.T - the common element base typesources - the Iterable of MaybeSources@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeDelayError(ObservableSource<? extends MaybeSource<? extends T>> sources)
This behaves like merge(ObservableSource) except that if any of the merged ObservableSources notify of an
error via onError, mergeDelayError will refrain from propagating that
error notification until all of the merged ObservableSources have finished emitting items.
Even if multiple merged ObservableSources send onError notifications, mergeDelayError will only
invoke the onError method of its Observers once.
mergeDelayError does not operate by default on a particular Scheduler.T - the common element base typesources - an ObservableSource that emits MaybeSourcessource ObservableSource@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeDelayError(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)
This behaves like merge(MaybeSource, MaybeSource) except that if any of the merged MaybeSources
notify of an error via onError, mergeDelayError will refrain from
propagating that error notification until all of the merged MaybeSources have finished emitting items.
Even if both merged MaybeSources send onError notifications, mergeDelayError will only
invoke the onError method of its Observers once.
mergeDelayError does not operate by default on a particular Scheduler.T - the common element base typesource1 - a MaybeSource to be mergedsource2 - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeDelayError(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3)
This behaves like merge(MaybeSource, MaybeSource, MaybeSource) except that if any of the merged
MaybeSources notify of an error via onError, mergeDelayError will refrain
from propagating that error notification until all of the merged MaybeSources have finished emitting
items.
Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only
invoke the onError method of its Observers once.
mergeDelayError does not operate by default on a particular Scheduler.T - the common element base typesource1 - a MaybeSource to be mergedsource2 - a MaybeSource to be mergedsource3 - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="none") public static <T> Observable<T> mergeDelayError(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, MaybeSource<? extends T> source3, MaybeSource<? extends T> source4)
This behaves like merge(MaybeSource, MaybeSource, MaybeSource, MaybeSource) except that if any of
the merged MaybeSources notify of an error via onError, mergeDelayError
will refrain from propagating that error notification until all of the merged MaybeSources have finished
emitting items.
Even if multiple merged MaybeSources send onError notifications, mergeDelayError will only
invoke the onError method of its Observers once.
mergeDelayError does not operate by default on a particular Scheduler.T - the common element base typesource1 - a MaybeSource to be mergedsource2 - a MaybeSource to be mergedsource3 - a MaybeSource to be mergedsource4 - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> never()
MaybeObserver.
This Maybe is useful primarily for testing purposes.
never does not operate by default on a particular Scheduler.T - the type of items (not) emitted by the MaybeMaybeObserver@CheckReturnValue @SchedulerSupport(value="none") public static <T> Single<java.lang.Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2)
sequenceEqual does not operate by default on a particular Scheduler.T - the type of items emitted by each MaybeSourcesource1 - the first MaybeSource to comparesource2 - the second MaybeSource to compare@CheckReturnValue @SchedulerSupport(value="none") public static <T> Single<java.lang.Boolean> sequenceEqual(MaybeSource<? extends T> source1, MaybeSource<? extends T> source2, io.reactivex.common.functions.BiPredicate<? super T,? super T> isEqual)
sequenceEqual does not operate by default on a particular Scheduler.T - the type of items emitted by each MaybeSourcesource1 - the first MaybeSource to comparesource2 - the second MaybeSource to compareisEqual - a function used to compare items emitted by each MaybeSource@CheckReturnValue @SchedulerSupport(value="io.reactivex:computation") public static Maybe<java.lang.Long> timer(long delay, java.util.concurrent.TimeUnit unit)
0L after a specified delay.
timer operates by default on the computation Scheduler.delay - the initial delay before emitting a single 0Lunit - time units to use for delay0L after a specified delay@CheckReturnValue @SchedulerSupport(value="custom") public static Maybe<java.lang.Long> timer(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.common.Scheduler scheduler)
0L after a specified delay on a specified Scheduler.
Scheduler this operator will usedelay - the initial delay before emitting a single 0Lunit - time units to use for delayscheduler - the Scheduler to use for scheduling the item0L after a specified delay, on a specified Scheduler@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> unsafeCreate(MaybeSource<T> onSubscribe)
unsafeCreate does not operate by default on a particular Scheduler.T - the value typeonSubscribe - the function that is called with the subscribing MaybeObserver@CheckReturnValue @SchedulerSupport(value="none") public static <T,D> Maybe<T> using(java.util.concurrent.Callable<? extends D> resourceSupplier, io.reactivex.common.functions.Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier, io.reactivex.common.functions.Consumer<? super D> resourceDisposer)
using does not operate by default on a particular Scheduler.T - the element type of the generated MaybeSourceD - the type of the resource associated with the output sequenceresourceSupplier - the factory function to create a resource object that depends on the MaybesourceSupplier - the factory function to create a MaybeSourceresourceDisposer - the function that will dispose of the resource@CheckReturnValue @SchedulerSupport(value="none") public static <T,D> Maybe<T> using(java.util.concurrent.Callable<? extends D> resourceSupplier, io.reactivex.common.functions.Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier, io.reactivex.common.functions.Consumer<? super D> resourceDisposer, boolean eager)
disposeEagerly to true and a downstream dispose() does not occur
before termination. Otherwise resource disposal will occur on call to dispose(). Eager disposal is
particularly appropriate for a synchronous Maybe that reuses resources. disposeAction will
only be called once per subscription.
using does not operate by default on a particular Scheduler.T - the element type of the generated MaybeSourceD - the type of the resource associated with the output sequenceresourceSupplier - the factory function to create a resource object that depends on the MaybesourceSupplier - the factory function to create a MaybeSourceresourceDisposer - the function that will dispose of the resourceeager - if true then disposal will happen either on a dispose() call or just before emission of
a terminal event (onComplete or onError).@CheckReturnValue @SchedulerSupport(value="none") public static <T> Maybe<T> wrap(MaybeSource<T> source)
wrap does not operate by default on a particular Scheduler.T - the value typesource - the source to wrap@CheckReturnValue @SchedulerSupport(value="none") public static <T,R> Maybe<R> zip(java.lang.Iterable<? extends MaybeSource<? extends T>> sources, io.reactivex.common.functions.Function<? super java.lang.Object[],? extends R> zipper)
Note on method signature: since Java doesn't allow creating a generic array with new T[], the
implementation of this operator has to create an Object[] instead. Unfortunately, a
Function<Integer[], R> passed to the method would trigger a ClassCastException.
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T - the common value typeR - the zipped result typesources - an Iterable of source MaybeSourceszipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, io.reactivex.common.functions.BiFunction<? super T1,? super T2,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results
in an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, io.reactivex.common.functions.Function3<? super T1,? super T2,? super T3,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,T4,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, MaybeSource<? extends T4> source4, io.reactivex.common.functions.Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceT4 - the value type of the fourth sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcesource4 - a fourth source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,T4,T5,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, MaybeSource<? extends T4> source4, MaybeSource<? extends T5> source5, io.reactivex.common.functions.Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceT4 - the value type of the fourth sourceT5 - the value type of the fifth sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcesource4 - a fourth source MaybeSourcesource5 - a fifth source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,T4,T5,T6,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, MaybeSource<? extends T4> source4, MaybeSource<? extends T5> source5, MaybeSource<? extends T6> source6, io.reactivex.common.functions.Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceT4 - the value type of the fourth sourceT5 - the value type of the fifth sourceT6 - the value type of the sixth sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcesource4 - a fourth source MaybeSourcesource5 - a fifth source MaybeSourcesource6 - a sixth source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,T4,T5,T6,T7,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, MaybeSource<? extends T4> source4, MaybeSource<? extends T5> source5, MaybeSource<? extends T6> source6, MaybeSource<? extends T7> source7, io.reactivex.common.functions.Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceT4 - the value type of the fourth sourceT5 - the value type of the fifth sourceT6 - the value type of the sixth sourceT7 - the value type of the seventh sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcesource4 - a fourth source MaybeSourcesource5 - a fifth source MaybeSourcesource6 - a sixth source MaybeSourcesource7 - a seventh source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,T4,T5,T6,T7,T8,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, MaybeSource<? extends T4> source4, MaybeSource<? extends T5> source5, MaybeSource<? extends T6> source6, MaybeSource<? extends T7> source7, MaybeSource<? extends T8> source8, io.reactivex.common.functions.Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zip does not operate by default on a particular Scheduler.T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceT4 - the value type of the fourth sourceT5 - the value type of the fifth sourceT6 - the value type of the sixth sourceT7 - the value type of the seventh sourceT8 - the value type of the eighth sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcesource4 - a fourth source MaybeSourcesource5 - a fifth source MaybeSourcesource6 - a sixth source MaybeSourcesource7 - a seventh source MaybeSourcesource8 - an eighth source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> Maybe<R> zip(MaybeSource<? extends T1> source1, MaybeSource<? extends T2> source2, MaybeSource<? extends T3> source3, MaybeSource<? extends T4> source4, MaybeSource<? extends T5> source5, MaybeSource<? extends T6> source6, MaybeSource<? extends T7> source7, MaybeSource<? extends T8> source8, MaybeSource<? extends T9> source9, io.reactivex.common.functions.Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
zip does not operate by default on a particular Scheduler.This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
T1 - the value type of the first sourceT2 - the value type of the second sourceT3 - the value type of the third sourceT4 - the value type of the fourth sourceT5 - the value type of the fifth sourceT6 - the value type of the sixth sourceT7 - the value type of the seventh sourceT8 - the value type of the eighth sourceT9 - the value type of the ninth sourceR - the zipped result typesource1 - the first source MaybeSourcesource2 - a second source MaybeSourcesource3 - a third source MaybeSourcesource4 - a fourth source MaybeSourcesource5 - a fifth source MaybeSourcesource6 - a sixth source MaybeSourcesource7 - a seventh source MaybeSourcesource8 - an eighth source MaybeSourcesource9 - a ninth source MaybeSourcezipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting MaybeSource@CheckReturnValue @SchedulerSupport(value="none") public static <T,R> Maybe<R> zipArray(io.reactivex.common.functions.Function<? super java.lang.Object[],? extends R> zipper, MaybeSource<? extends T>... sources)
Note on method signature: since Java doesn't allow creating a generic array with new T[], the
implementation of this operator has to create an Object[] instead. Unfortunately, a
Function<Integer[], R> passed to the method would trigger a ClassCastException.
This operator terminates eagerly if any of the source MaybeSources signal an onError or onComplete. This also means it is possible some sources may not get subscribed to at all.
zipArray does not operate by default on a particular Scheduler.T - the common element typeR - the result typesources - an array of source MaybeSourceszipper - a function that, when applied to an item emitted by each of the source MaybeSources, results in
an item that will be emitted by the resulting MaybeSource@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> ambWith(MaybeSource<? extends T> other)
ambWith does not operate by default on a particular Scheduler.other - a MaybeSource competing to react first. A subscription to this provided source will occur after
subscribing to the current source.@CheckReturnValue @SchedulerSupport(value="none") public final T blockingGet()
blockingGet does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final T blockingGet(T defaultValue)
blockingGet does not operate by default on a particular Scheduler.defaultValue - the default item to return if this Maybe is empty@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> cache()
The operator subscribes only when the first downstream subscriber subscribes and maintains a single subscription towards this Maybe.
Note: You sacrifice the ability to dispose the origin when you use the cache.
cache does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<U> cast(java.lang.Class<? extends U> clazz)
cast does not operate by default on a particular Scheduler.U - the target typeclazz - the type token to use for casting the success result from the current Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> compose(MaybeTransformer<? super T,? extends R> transformer)
This method operates on the Maybe itself whereas lift(io.reactivex.observable.MaybeOperator<? extends R, ? super T>) operates on the Maybe's MaybeObservers.
If the operator you are creating is designed to act on the individual item emitted by a Maybe, use
lift(io.reactivex.observable.MaybeOperator<? extends R, ? super T>). If your operator is designed to transform the source Maybe as a whole (for instance, by
applying a particular set of existing RxJava operators to it) use compose.
compose does not operate by default on a particular Scheduler.R - the value type of the Maybe returned by the transformer functiontransformer - the transformer function, not null@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> concatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends R>> mapper)
concatMap does not operate by default on a particular Scheduler.Note that flatMap and concatMap for Maybe is the same operation.
R - the result value typemapper - a function that, when applied to the item emitted by the source Maybe, returns a MaybeSourcefunc when applied to the item emitted by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> concatWith(MaybeSource<? extends T> other)
concatWith does not operate by default on a particular Scheduler.other - a MaybeSource to be concatenated after the current@CheckReturnValue @SchedulerSupport(value="none") public final Single<java.lang.Boolean> contains(java.lang.Object item)
contains does not operate by default on a particular Scheduler.item - the item to search for in the emissions from the source Maybe, not nulltrue if the specified item is emitted by the source Maybe,
or false if the source Maybe completes without emitting that item@CheckReturnValue @SchedulerSupport(value="none") public final Single<java.lang.Long> count()
count does not operate by default on a particular Scheduler.count()@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> defaultIfEmpty(T defaultItem)
defaultIfEmpty does not operate by default on a particular Scheduler.defaultItem - the item to emit if the source Maybe emits no items@CheckReturnValue @SchedulerSupport(value="io.reactivex:computation") public final Maybe<T> delay(long delay, java.util.concurrent.TimeUnit unit)
delay operates by default on the computation Scheduler.delay - the delay to shift the source byunit - the TimeUnit in which period is defined@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> delay(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.common.Scheduler scheduler)
Scheduler this operator will usedelay - the delay to shift the source byunit - the time unit of delayscheduler - the Scheduler to use for delaying@CheckReturnValue @SchedulerSupport(value="none") public final <U,V> Maybe<T> delay(ObservableSource<U> delayIndicator)
delay does not operate by default on a particular Scheduler.U - the subscription delay value type (ignored)V - the item delay value type (ignored)delayIndicator - the ObservableSource that gets subscribed to when this Maybe signals an event and that
signal is emitted when the ObservableSource signals an item or completes@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> delaySubscription(ObservableSource<U> subscriptionIndicator)
Scheduler.U - the value type of the other ObservableSource, irrelevantsubscriptionIndicator - the other ObservableSource that should trigger the subscription
to this ObservableSource.@CheckReturnValue @SchedulerSupport(value="io.reactivex:computation") public final Maybe<T> delaySubscription(long delay, java.util.concurrent.TimeUnit unit)
delaySubscription operates by default on the computation Scheduler.delay - the time to delay the subscriptionunit - the time unit of delay@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> delaySubscription(long delay, java.util.concurrent.TimeUnit unit, io.reactivex.common.Scheduler scheduler)
Scheduler this operator will usedelay - the time to delay the subscriptionunit - the time unit of delayscheduler - the Scheduler on which the waiting and subscription will happen@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doAfterSuccess(io.reactivex.common.functions.Consumer<? super T> onAfterSuccess)
Note that the onAfterNext action is shared between subscriptions and as such
should be thread-safe.
doAfterSuccess does not operate by default on a particular Scheduler.onAfterSuccess - the Consumer that will be called after emitting an item from upstream to the downstream@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doAfterTerminate(io.reactivex.common.functions.Action onAfterTerminate)
Action to be called when this Maybe invokes either
onSuccess,
onComplete or onError.
doAfterTerminate does not operate by default on a particular Scheduler.onAfterTerminate - an Action to be invoked when the source Maybe finishesAction@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doFinally(io.reactivex.common.functions.Action onFinally)
In case of a race between a terminal event and a dispose call, the provided onFinally action
is executed once per subscription.
Note that the onFinally action is shared between subscriptions and as such
should be thread-safe.
doFinally does not operate by default on a particular Scheduler.onFinally - the action called when this Maybe terminates or gets cancelled@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doOnDispose(io.reactivex.common.functions.Action onDispose)
doOnDispose does not operate by default on a particular Scheduler.onDispose - the runnable called when the subscription is cancelled (disposed)@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doOnComplete(io.reactivex.common.functions.Action onComplete)
onComplete.
doOnComplete does not operate by default on a particular Scheduler.onComplete - the action to invoke when the source Maybe calls onComplete@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doOnError(io.reactivex.common.functions.Consumer<? super java.lang.Throwable> onError)
doOnError does not operate by default on a particular Scheduler.onError - the consumer called with the success value of onError@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doOnEvent(io.reactivex.common.functions.BiConsumer<? super T,? super java.lang.Throwable> onEvent)
Exceptions thrown from the callback will override the event so the downstream receives the error instead of the original signal.
doOnEvent does not operate by default on a particular Scheduler.onEvent - the callback to call with the terminal event tuple@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doOnSubscribe(io.reactivex.common.functions.Consumer<? super io.reactivex.common.Disposable> onSubscribe)
doOnSubscribe does not operate by default on a particular Scheduler.onSubscribe - the consumer called with the Disposable sent via onSubscribe@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> doOnSuccess(io.reactivex.common.functions.Consumer<? super T> onSuccess)
doOnSuccess does not operate by default on a particular Scheduler.onSuccess - the consumer called with the success value of onSuccess@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> filter(io.reactivex.common.functions.Predicate<? super T> predicate)
filter does not operate by default on a particular Scheduler.predicate - a function that evaluates the item emitted by the source Maybe, returning true
if it passes the filtertrue@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> flatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends R>> mapper)
flatMap does not operate by default on a particular Scheduler.Note that flatMap and concatMap for Maybe is the same operation.
R - the result value typemapper - a function that, when applied to the item emitted by the source Maybe, returns a MaybeSourcefunc when applied to the item emitted by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> flatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper, io.reactivex.common.functions.Function<? super java.lang.Throwable,? extends MaybeSource<? extends R>> onErrorMapper, java.util.concurrent.Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
flatMap does not operate by default on a particular Scheduler.R - the result typeonSuccessMapper - a function that returns a MaybeSource to merge for the onSuccess item emitted by this MaybeonErrorMapper - a function that returns a MaybeSource to merge for an onError notification from this MaybeonCompleteSupplier - a function that returns a MaybeSource to merge for an onComplete notification this Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <U,R> Maybe<R> flatMap(io.reactivex.common.functions.Function<? super T,? extends MaybeSource<? extends U>> mapper, io.reactivex.common.functions.BiFunction<? super T,? super U,? extends R> resultSelector)
flatMap does not operate by default on a particular Scheduler.U - the type of items emitted by the MaybeSource returned by the mapper functionR - the type of items emitted by the resulting Maybemapper - a function that returns a MaybeSource for the item emitted by the source MayberesultSelector - a function that combines one item emitted by each of the source and collection MaybeSource and
returns an item to be emitted by the resulting MaybeSource@CheckReturnValue @SchedulerSupport(value="none") public final <U> Observable<U> flattenAsObservable(io.reactivex.common.functions.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
flattenAsObservable does not operate by default on a particular Scheduler.U - the type of item emitted by the resulting Iterablemapper - a function that returns an Iterable sequence of values for when given an item emitted by the
source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> Observable<R> flatMapObservable(io.reactivex.common.functions.Function<? super T,? extends ObservableSource<? extends R>> mapper)
flatMapObservable does not operate by default on a particular Scheduler.R - the result value typemapper - a function that, when applied to the item emitted by the source Maybe, returns an ObservableSourcefunc when applied to the item emitted by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> Single<R> flatMapSingle(io.reactivex.common.functions.Function<? super T,? extends SingleSource<? extends R>> mapper)
Single based on applying a specified function to the item emitted by the
source Maybe, where that function returns a Single.
When this Maybe completes a NoSuchElementException will be thrown.
flatMapSingle does not operate by default on a particular Scheduler.R - the result value typemapper - a function that, when applied to the item emitted by the source Maybe, returns a
Singlemapper when applied to the item emitted by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> flatMapSingleElement(io.reactivex.common.functions.Function<? super T,? extends SingleSource<? extends R>> mapper)
Maybe based on applying a specified function to the item emitted by the
source Maybe, where that function returns a Single.
When this Maybe just completes the resulting Maybe completes as well.
flatMapSingleElement does not operate by default on a particular Scheduler.R - the result value typemapper - a function that, when applied to the item emitted by the source Maybe, returns a
Single@CheckReturnValue @SchedulerSupport(value="none") public final Completable flatMapCompletable(io.reactivex.common.functions.Function<? super T,? extends CompletableSource> mapper)
Completable that completes based on applying a specified function to the item emitted by the
source Maybe, where that function returns a Completable.
flatMapCompletable does not operate by default on a particular Scheduler.mapper - a function that, when applied to the item emitted by the source Maybe, returns a
Completablemapper when applied to the item emitted by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> hide()
Allows preventing certain identity-based optimizations (fusion).
hide does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Completable ignoreElement()
onComplete or onError.
ignoreElement does not operate by default on a particular Scheduler.onComplete or onError, based on which one is
called by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final Single<java.lang.Boolean> isEmpty()
true if the source Maybe is empty, otherwise false.
isEmpty does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> lift(MaybeOperator<? extends R,? super T> lift)
In other words, this allows chaining TaskExecutors together on a Maybe for acting on the values within the Maybe.
task.map(...).filter(...).lift(new OperatorA()).lift(new OperatorB(...)).subscribe()
If the operator you are creating is designed to act on the item emitted by a source Maybe, use
lift. If your operator is designed to transform the source Maybe as a whole (for instance, by
applying a particular set of existing RxJava operators to it) use compose(io.reactivex.observable.MaybeTransformer<? super T, ? extends R>).
lift does not operate by default on a particular Scheduler.R - the downstream's value type (output)lift - the MaybeOperator that implements the Maybe-operating function to be applied to the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> Maybe<R> map(io.reactivex.common.functions.Function<? super T,? extends R> mapper)
map does not operate by default on a particular Scheduler.R - the result value typemapper - a function to apply to the item emitted by the Maybe@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> mergeWith(MaybeSource<? extends T> other)
You can combine items emitted by multiple Maybes so that they appear as a single Observable, by
using the mergeWith method.
mergeWith does not operate by default on a particular Scheduler.other - a MaybeSource to be merged@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> observeOn(io.reactivex.common.Scheduler scheduler)
Scheduler,
asynchronously.
Scheduler this operator will usescheduler - the Scheduler to notify subscribers onSchedulersubscribeOn(io.reactivex.common.Scheduler)@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<U> ofType(java.lang.Class<U> clazz)
ofType does not operate by default on a particular Scheduler.U - the output typeclazz - the class type to filter the items emitted by the source Maybe@CheckReturnValue @SchedulerSupport(value="none") public final <R> R to(io.reactivex.common.functions.Function<? super Maybe<T>,R> convert)
to does not operate by default on a particular Scheduler.R - the result typeconvert - the function that is called with the current Maybe instance during
assembly time that should return some value to be the result@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> toObservable()
toObservable does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Single<T> toSingle(T defaultValue)
toSingle does not operate by default on a particular Scheduler.defaultValue - the default item to signal in Single if this Maybe is empty@CheckReturnValue @SchedulerSupport(value="none") public final Single<T> toSingle()
toSingle does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onErrorComplete()
onErrorComplete does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onErrorComplete(io.reactivex.common.functions.Predicate<? super java.lang.Throwable> predicate)
onErrorComplete does not operate by default on a particular Scheduler.predicate - the predicate to call when an Throwable is emitted which should return true
if the Throwable should be swallowed and replaced with an onComplete.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onErrorResumeNext(MaybeSource<? extends T> next)
onError if it encounters an error.
You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
onErrorResumeNext does not operate by default on a particular Scheduler.next - the next Maybe source that will take over if the source Maybe encounters
an error@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onErrorResumeNext(io.reactivex.common.functions.Function<? super java.lang.Throwable,? extends MaybeSource<? extends T>> resumeFunction)
onError if it encounters an error.
You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
onErrorResumeNext does not operate by default on a particular Scheduler.resumeFunction - a function that returns a MaybeSource that will take over if the source Maybe encounters
an error@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onErrorReturn(io.reactivex.common.functions.Function<? super java.lang.Throwable,? extends T> valueSupplier)
onError if it encounters an error.
You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
onErrorReturn does not operate by default on a particular Scheduler.valueSupplier - a function that returns a single value that will be emitted as success value
the current Maybe signals an onError event@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onErrorReturnItem(T item)
onError if it encounters an error.
You can use this to prevent errors from propagating or to supply fallback data should errors be encountered.
onErrorReturnItem does not operate by default on a particular Scheduler.item - the value that is emitted as onSuccess in case this Maybe signals an onError@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onExceptionResumeNext(MaybeSource<? extends T> next)
onError if it encounters an Exception.
This differs from onErrorResumeNext(io.reactivex.observable.MaybeSource<? extends T>) in that this one does not handle Throwable
or Error but lets those continue through.
You can use this to prevent exceptions from propagating or to supply fallback data should exceptions be encountered.
onExceptionResumeNext does not operate by default on a particular Scheduler.next - the next MaybeSource that will take over if the source Maybe encounters
an exception@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> onTerminateDetach()
onTerminateDetach does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> repeat()
repeat does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> repeat(long times)
count times.
repeat does not operate by default on a particular Scheduler.times - the number of times the source Maybe items are repeated, a count of 0 will yield an empty
sequencecount timesjava.lang.IllegalArgumentException - if count is less than zero@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> repeatUntil(io.reactivex.common.functions.BooleanSupplier stop)
repeatUntil does not operate by default on a particular Scheduler.stop - a boolean supplier that is called when the current Observable completes and unless it returns
false, the current Observable is resubscribedjava.lang.NullPointerException - if stop is null@CheckReturnValue @SchedulerSupport(value="none") public final Observable<T> repeatWhen(io.reactivex.common.functions.Function<? super Observable<java.lang.Object>,? extends ObservableSource<?>> handler)
onComplete. An onComplete notification from the source will result in the emission of
a void item to the ObservableSource provided as an argument to the notificationHandler
function. If that ObservableSource calls onComplete or onError then repeatWhen will
call onComplete or onError on the child subscription. Otherwise, this ObservableSource will
resubscribe to the source ObservableSource.
repeatWhen does not operate by default on a particular Scheduler.handler - receives an ObservableSource of notifications with which a user can complete or error, aborting the repeat.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retry()
onError
(infinite retry count).
If the source Maybe calls MaybeObserver.onError(java.lang.Throwable), this method will resubscribe to the source
Maybe rather than propagating the onError call.
retry does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retry(io.reactivex.common.functions.BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)
onError
and the predicate returns true for that specific exception and retry count.
retry does not operate by default on a particular Scheduler.predicate - the predicate that determines if a resubscription may happen in case of a specific exception
and retry countretry(),
ReactiveX operators documentation: Retry@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retry(long count)
onError
up to a specified number of retries.
If the source Maybe calls MaybeObserver.onError(java.lang.Throwable), this method will resubscribe to the source
Maybe for a maximum of count resubscriptions rather than propagating the
onError call.
retry does not operate by default on a particular Scheduler.count - number of retry attempts before failing@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retry(long times, io.reactivex.common.functions.Predicate<? super java.lang.Throwable> predicate)
retry does not operate by default on a particular Scheduler.times - the number of times to repeatpredicate - the predicate called with the failure Throwable and should return true to trigger a retry.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retry(io.reactivex.common.functions.Predicate<? super java.lang.Throwable> predicate)
retry does not operate by default on a particular Scheduler.predicate - the predicate that receives the failure Throwable and should return true to trigger a retry.@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retryUntil(io.reactivex.common.functions.BooleanSupplier stop)
retryUntil does not operate by default on a particular Scheduler.stop - the function that should return true to stop retrying@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> retryWhen(io.reactivex.common.functions.Function<? super Observable<java.lang.Throwable>,? extends ObservableSource<?>> handler)
onError. An onError notification from the source will result in the emission of a
Throwable item to the ObservableSource provided as an argument to the notificationHandler
function. If that ObservableSource calls onComplete or onError then retry will call
onComplete or onError on the child subscription. Otherwise, this ObservableSource will
resubscribe to the source ObservableSource.
Example:
This retries 3 times, each time incrementing the number of seconds it waits.
ObservableSource.create((Observer super String> s) -> {
System.out.println("subscribing");
s.onError(new RuntimeException("always fails"));
}).retryWhen(attempts -> {
return attempts.zipWith(ObservableSource.range(1, 3), (n, i) -> i).flatMap(i -> {
System.out.println("delay retry by " + i + " second(s)");
return ObservableSource.timer(i, TimeUnit.SECONDS);
});
}).blockingForEach(System.out::println);
Output is:
subscribing
delay retry by 1 second(s)
subscribing
delay retry by 2 second(s)
subscribing
delay retry by 3 second(s)
subscribing
retryWhen does not operate by default on a particular Scheduler.handler - receives an ObservableSource of notifications with which a user can complete or error, aborting the
retry@SchedulerSupport(value="none") public final io.reactivex.common.Disposable subscribe()
onSuccess and onComplete emissions.
If the Maybe emits an error, it is wrapped into an
OnErrorNotImplementedException
and routed to the RxJavaCommonPlugins.onError handler.
subscribe does not operate by default on a particular Scheduler.Disposable reference with which the caller can stop receiving items before
the Maybe has finished sending them@CheckReturnValue @SchedulerSupport(value="none") public final io.reactivex.common.Disposable subscribe(io.reactivex.common.functions.Consumer<? super T> onSuccess)
If the Maybe emits an error, it is wrapped into an
OnErrorNotImplementedException
and routed to the RxJavaCommonPlugins.onError handler.
subscribe does not operate by default on a particular Scheduler.onSuccess - the Consumer<T> you have designed to accept a success value from the MaybeDisposable reference with which the caller can stop receiving items before
the Maybe has finished sending themjava.lang.NullPointerException - if onSuccess is null@CheckReturnValue @SchedulerSupport(value="none") public final io.reactivex.common.Disposable subscribe(io.reactivex.common.functions.Consumer<? super T> onSuccess, io.reactivex.common.functions.Consumer<? super java.lang.Throwable> onError)
subscribe does not operate by default on a particular Scheduler.onSuccess - the Consumer<T> you have designed to accept a success value from the MaybeonError - the Consumer<Throwable> you have designed to accept any error notification from the
MaybeDisposable reference with which the caller can stop receiving items before
the Maybe has finished sending themjava.lang.NullPointerException - if onSuccess is null, or
if onError is null@CheckReturnValue @SchedulerSupport(value="none") public final io.reactivex.common.Disposable subscribe(io.reactivex.common.functions.Consumer<? super T> onSuccess, io.reactivex.common.functions.Consumer<? super java.lang.Throwable> onError, io.reactivex.common.functions.Action onComplete)
subscribe does not operate by default on a particular Scheduler.onSuccess - the Consumer<T> you have designed to accept a success value from the MaybeonError - the Consumer<Throwable> you have designed to accept any error notification from the
MaybeonComplete - the Action you have designed to accept a completion notification from the
MaybeDisposable reference with which the caller can stop receiving items before
the Maybe has finished sending themjava.lang.NullPointerException - if onSuccess is null, or
if onError is null, or
if onComplete is null@SchedulerSupport(value="none") public final void subscribe(MaybeObserver<? super T> observer)
MaybeSourcesubscribe in interface MaybeSource<T>observer - the MaybeObserver, not nullprotected abstract void subscribeActual(MaybeObserver<? super T> observer)
observer - the MaybeObserver to handle, not null@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> subscribeOn(io.reactivex.common.Scheduler scheduler)
Scheduler.
Scheduler this operator will usescheduler - the Scheduler to perform subscription actions onSchedulerobserveOn(io.reactivex.common.Scheduler)@CheckReturnValue @SchedulerSupport(value="none") public final <E extends MaybeObserver<? super T>> E subscribeWith(E observer)
Usage example:
Maybe<Integer> source = Maybe.just(1);
CompositeDisposable composite = new CompositeDisposable();
MaybeObserver<Integer> ms = new MaybeObserver<>() {
// ...
};
composite.add(source.subscribeWith(ms));
subscribeWith does not operate by default on a particular Scheduler.E - the type of the MaybeObserver to use and returnobserver - the MaybeObserver (subclass) to use and return, not nullsubscriberjava.lang.NullPointerException - if subscriber is null@CheckReturnValue @SchedulerSupport(value="none") public final Maybe<T> switchIfEmpty(MaybeSource<? extends T> other)
switchIfEmpty does not operate by default on a particular Scheduler.other - the alternate MaybeSource to subscribe to if the main does not emit any items@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> takeUntil(MaybeSource<U> other)
takeUntil does not operate by default on a particular Scheduler.U - the type of items emitted by otherother - the MaybeSource whose first emitted item will cause takeUntil to stop emitting items
from the source Maybeother emits its first item@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> takeUntil(ObservableSource<U> other)
takeUntil does not operate by default on a particular Scheduler.U - the type of items emitted by otherother - the ObservableSource whose first emitted item will cause takeUntil to stop emitting items
from the source ObservableSourceother emits its first item@CheckReturnValue @SchedulerSupport(value="io.reactivex:computation") public final Maybe<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit)
TimeoutException.
timeout operates by default on the computation Scheduler.timeout - maximum duration between emitted items before a timeout occurstimeUnit - the unit of time that applies to the timeout argument.@CheckReturnValue @SchedulerSupport(value="io.reactivex:computation") public final Maybe<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, MaybeSource<? extends T> fallback)
timeout operates by default on the computation Scheduler.timeout - maximum duration between items before a timeout occurstimeUnit - the unit of time that applies to the timeout argumentfallback - the fallback MaybeSource to use in case of a timeout@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, io.reactivex.common.Scheduler scheduler, MaybeSource<? extends T> fallback)
Scheduler this operator will usetimeout - maximum duration between items before a timeout occurstimeUnit - the unit of time that applies to the timeout argumentfallback - the MaybeSource to use as the fallback in case of a timeoutscheduler - the Scheduler to run the timeout timers on@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> timeout(long timeout, java.util.concurrent.TimeUnit timeUnit, io.reactivex.common.Scheduler scheduler)
TimeoutException.
Scheduler this operator will usetimeout - maximum duration between items before a timeout occurstimeUnit - the unit of time that applies to the timeout argumentscheduler - the Scheduler to run the timeout timers on@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> timeout(MaybeSource<U> timeoutIndicator)
timeout does not operate by default on a particular Scheduler.U - the value type of thetimeoutIndicator - the MaybeSource that indicates the timeout by signalling onSuccess
or onComplete.@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> timeout(MaybeSource<U> timeoutIndicator, MaybeSource<? extends T> fallback)
fallback MaybeSource subscribed to
as a continuation.
timeout does not operate by default on a particular Scheduler.U - the value type of thetimeoutIndicator - the MaybeSource that indicates the timeout by signalling onSuccess
or onComplete.fallback - the MaybeSource that is subscribed to if the current Maybe times out@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> timeout(ObservableSource<U> timeoutIndicator)
timeout does not operate by default on a particular Scheduler.U - the value type of thetimeoutIndicator - the MaybeSource that indicates the timeout by signalling onSuccess
or onComplete.@CheckReturnValue @SchedulerSupport(value="none") public final <U> Maybe<T> timeout(ObservableSource<U> timeoutIndicator, MaybeSource<? extends T> fallback)
fallback MaybeSource subscribed to
as a continuation.
timeout does not operate by default on a particular Scheduler.U - the value type of thetimeoutIndicator - the MaybeSource that indicates the timeout by signalling onSuccess
or onCompletefallback - the MaybeSource that is subscribed to if the current Maybe times out@CheckReturnValue @SchedulerSupport(value="custom") public final Maybe<T> unsubscribeOn(io.reactivex.common.Scheduler scheduler)
unsubscribeOn calls dispose() of the upstream on the Scheduler you specify.scheduler - the target scheduler where to execute the cancellationjava.lang.NullPointerException - if scheduler is null@CheckReturnValue @SchedulerSupport(value="none") public final <U,R> Maybe<R> zipWith(MaybeSource<? extends U> other, io.reactivex.common.functions.BiFunction<? super T,? super U,? extends R> zipper)
If either this or the other MaybeSource is empty or signals an error, the resulting Maybe will terminate immediately and dispose the other source.
zipWith does not operate by default on a particular Scheduler.U - the type of items emitted by the other MaybeSourceR - the type of items emitted by the resulting Maybeother - the other MaybeSourcezipper - a function that combines the pairs of items from the two MaybeSources to generate the items to
be emitted by the resulting Maybe@CheckReturnValue @SchedulerSupport(value="none") public final TestObserver<T> test()
test does not operate by default on a particular Scheduler.@CheckReturnValue @SchedulerSupport(value="none") public final TestObserver<T> test(boolean cancelled)
test does not operate by default on a particular Scheduler.cancelled - if true, the TestObserver will be cancelled before subscribing to this
Maybe.