Package | Description |
---|---|
io.reactivex |
Base reactive classes:
Flowable , Observable ,
Single , Maybe and
Completable ; base reactive consumers;
other common base interfaces. |
io.reactivex.internal.fuseable |
Base interfaces and types for supporting operator-fusion.
|
io.reactivex.internal.operators.flowable | |
io.reactivex.internal.operators.maybe | |
io.reactivex.internal.operators.mixed | |
io.reactivex.internal.operators.observable | |
io.reactivex.internal.operators.single | |
io.reactivex.subjects |
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and
the respective consumer type at once to allow forms of multicasting events to multiple
consumers as well as consuming another base reactive type of their kind.
|
Modifier and Type | Class and Description |
---|---|
class |
Maybe<T>
Represents a deferred computation and emission of a maybe value or exception.
|
Modifier and Type | Method and Description |
---|---|
MaybeSource<Downstream> |
MaybeTransformer.apply(Maybe<Upstream> upstream)
Applies a function to the upstream Maybe and returns a MaybeSource with
optionally different element type.
|
Modifier and Type | Method and Description |
---|---|
static <T> Maybe<T> |
Maybe.ambArray(MaybeSource<? extends T>... sources)
Runs multiple MaybeSources and signals the events of the first one that signals (cancelling
the rest).
|
Maybe<T> |
Maybe.ambWith(MaybeSource<? extends T> other)
Mirrors the MaybeSource (current or provided) that first signals an event.
|
<T> Maybe<T> |
Completable.andThen(MaybeSource<T> next)
Returns a
Maybe which will subscribe to this Completable and once that is completed then
will subscribe to the next MaybeSource. |
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concat(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.
|
static <T> Flowable<T> |
Maybe.concatArray(MaybeSource<? extends T>... sources)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array.
|
static <T> Flowable<T> |
Maybe.concatArrayDelayError(MaybeSource<? extends T>... sources)
Concatenates a variable number of MaybeSource sources and delays errors from any of them
till all terminate.
|
static <T> Flowable<T> |
Maybe.concatArrayEager(MaybeSource<? extends T>... sources)
Concatenates a sequence of MaybeSource eagerly into a single stream of values.
|
Flowable<T> |
Maybe.concatWith(MaybeSource<? extends T> other)
Returns a Flowable that emits the items emitted from the current MaybeSource, then the next, one after
the other, without interleaving them.
|
Flowable<T> |
Flowable.concatWith(MaybeSource<? extends T> other)
Returns a
Flowable that emits the items from this Flowable followed by the success item or terminal events
of the other MaybeSource . |
Observable<T> |
Observable.concatWith(MaybeSource<? extends T> other)
Returns an
Observable that emits the items from this Observable followed by the success item or terminal events
of the other MaybeSource . |
static <T> Maybe<T> |
Maybe.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> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.mergeArray(MaybeSource<? extends T>... sources)
Merges an array sequence of MaybeSource instances into a single Flowable sequence,
running all MaybeSources at once.
|
static <T> Flowable<T> |
Maybe.mergeArrayDelayError(MaybeSource<? extends T>... sources)
Flattens an array of MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSource into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSource into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3)
Flattens three MaybeSource into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
MaybeSource<? extends T> source3,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source MaybeSources without being interrupted by an error
notification from one of them.
|
Flowable<T> |
Maybe.mergeWith(MaybeSource<? extends T> other)
Flattens this and another Maybe into a single Flowable, without any transformation.
|
Flowable<T> |
Flowable.mergeWith(MaybeSource<? extends T> other)
Merges the sequence of items of this Flowable with the success value of the other MaybeSource
or waits for both to complete normally if the MaybeSource is empty.
|
Observable<T> |
Observable.mergeWith(MaybeSource<? extends T> other)
Merges the sequence of items of this Observable with the success value of the other MaybeSource
or waits both to complete normally if the MaybeSource is empty.
|
Maybe<T> |
Maybe.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> |
Maybe.onExceptionResumeNext(MaybeSource<? extends T> next)
|
static <T> Single<Boolean> |
Maybe.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<Boolean> |
Maybe.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<Boolean> |
Maybe.sequenceEqual(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
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.
|
static <T> Single<Boolean> |
Maybe.sequenceEqual(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
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.
|
Maybe<T> |
Maybe.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> |
Maybe.takeUntil(MaybeSource<U> other)
Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource
emits an item.
|
Maybe<T> |
Maybe.timeout(long timeout,
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> |
Maybe.timeout(long timeout,
TimeUnit timeUnit,
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> |
Maybe.timeout(MaybeSource<U> timeoutIndicator)
If the current
Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, a
TimeoutException is signaled instead. |
<U> Maybe<T> |
Maybe.timeout(MaybeSource<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current
Maybe 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> |
Maybe.timeout(MaybeSource<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current
Maybe 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> |
Maybe.timeout(org.reactivestreams.Publisher<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current
Maybe didn't signal an event before the timeoutIndicator Publisher signals,
the current Maybe is cancelled and the fallback MaybeSource subscribed to
as a continuation. |
static <T> Maybe<T> |
Maybe.unsafeCreate(MaybeSource<T> onSubscribe)
Advanced use only: creates a Maybe instance without
any safeguards by using a callback that is called with a MaybeObserver.
|
static <T> Maybe<T> |
Maybe.wrap(MaybeSource<T> source)
Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe
instance.
|
static <T1,T2,R> Maybe<R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
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,R> Maybe<R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
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> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
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> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
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> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
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,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
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> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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,R> |
Maybe.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,
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> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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 <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.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,
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> |
Maybe.zipArray(Function<? super 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> |
Maybe.zipWith(MaybeSource<? extends U> other,
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.
|
Modifier and Type | Method and Description |
---|---|
static <T> Maybe<T> |
Maybe.amb(Iterable<? extends MaybeSource<? extends T>> sources)
Runs multiple MaybeSources and signals the events of the first one that signals (cancelling
the rest).
|
static <T> Flowable<T> |
Maybe.concat(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> Flowable<T> |
Maybe.concat(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by
a Publisher sequence.
|
static <T> Flowable<T> |
Maybe.concat(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources,
int prefetch)
Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by
a Publisher sequence.
|
static <T> Flowable<T> |
Maybe.concatDelayError(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> Flowable<T> |
Maybe.concatDelayError(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher,
one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.
|
static <T> Flowable<T> |
Maybe.concatEager(Iterable<? extends MaybeSource<? extends T>> sources)
Concatenates a sequence of MaybeSources eagerly into a single stream of values.
|
static <T> Flowable<T> |
Maybe.concatEager(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
Concatenates a Publisher sequence of MaybeSources eagerly into a single stream of values.
|
<R> Maybe<R> |
Maybe.concatMap(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> Flowable<R> |
Flowable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Flowable or the current inner MaybeSource fail. |
<R> Observable<R> |
Observable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Observable or the current inner MaybeSource fail. |
<R> Flowable<R> |
Flowable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Flowable or the current inner MaybeSource fail. |
<R> Observable<R> |
Observable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Observable or the current inner MaybeSource fail. |
<R> Flowable<R> |
Flowable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and delaying all errors
till both this Flowable and all inner MaybeSource s terminate. |
<R> Observable<R> |
Observable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and delaying all errors
till both this Observable and all inner MaybeSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Flowable and all inner MaybeSource s terminate. |
<R> Observable<R> |
Observable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Observable and all inner MaybeSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Flowable and all inner MaybeSource s terminate. |
<R> Observable<R> |
Observable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Observable and all inner MaybeSource s terminate. |
static <T> Maybe<T> |
Maybe.defer(Callable<? extends MaybeSource<? extends T>> maybeSupplier)
Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to
be subscribed to.
|
<R> Maybe<R> |
Maybe.flatMap(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> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that
MaybeSource's signals.
|
<R> Maybe<R> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that
MaybeSource's signals.
|
<R> Maybe<R> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that
MaybeSource's signals.
|
<U,R> Maybe<R> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends U>> mapper,
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.
|
<R> Flowable<R> |
Flowable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Flowable sequence.
|
<R> Maybe<R> |
Single.flatMapMaybe(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 Single,
where that function returns a MaybeSource.
|
<R> Observable<R> |
Observable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps each element of the upstream Observable into MaybeSources, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Observable sequence.
|
<R> Observable<R> |
Observable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors)
Maps each element of the upstream Observable into MaybeSources, subscribes to them
and merges their onSuccess values, in no particular order, into a single Observable sequence,
optionally delaying all errors.
|
<R> Flowable<R> |
Flowable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency)
Maps each element of the upstream Flowable into MaybeSources, subscribes to at most
maxConcurrency MaybeSources at a time and merges their onSuccess values,
in no particular order, into a single Flowable sequence, optionally delaying all errors. |
static <T> Flowable<T> |
Maybe.merge(Iterable<? extends MaybeSource<? extends T>> sources)
Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence,
running all MaybeSources at once.
|
static <T> Maybe<T> |
Maybe.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> Flowable<T> |
Maybe.merge(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence,
running all MaybeSources at once.
|
static <T> Flowable<T> |
Maybe.merge(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources,
int maxConcurrency)
Merges a Flowable sequence of MaybeSource instances into a single Flowable sequence,
running at most maxConcurrency MaybeSources at once.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(Iterable<? extends MaybeSource<? extends T>> sources)
Flattens an Iterable of MaybeSources into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source MaybeSources without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources)
Flattens a Publisher that emits MaybeSources into one Publisher, in a way that allows a Subscriber to
receive all successfully emitted items from all of the source MaybeSources without being interrupted by
an error notification from one of them or even the main Publisher.
|
static <T> Flowable<T> |
Maybe.mergeDelayError(org.reactivestreams.Publisher<? extends MaybeSource<? extends T>> sources,
int maxConcurrency)
Flattens a Publisher that emits MaybeSources into one Publisher, in a way that allows a Subscriber to
receive all successfully emitted items from all of the source MaybeSources without being interrupted by
an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources.
|
Maybe<T> |
Maybe.onErrorResumeNext(Function<? super Throwable,? extends MaybeSource<? extends T>> resumeFunction)
Instructs a Maybe to pass control to another Maybe rather than invoking
onError if it encounters an error. |
<R> Flowable<R> |
Flowable.switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available while failing immediately if this Flowable or any of the
active inner MaybeSource s fail. |
<R> Observable<R> |
Observable.switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available while failing immediately if this Observable or any of the
active inner MaybeSource s fail. |
<R> Flowable<R> |
Flowable.switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available, delaying errors from this Flowable or the inner MaybeSource s until all terminate. |
<R> Observable<R> |
Observable.switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available, delaying errors from this Observable or the inner MaybeSource s until all terminate. |
static <T,D> Maybe<T> |
Maybe.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
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> |
Maybe.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
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,R> Maybe<R> |
Maybe.zip(Iterable<? extends MaybeSource<? extends T>> sources,
Function<? super 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.
|
Modifier and Type | Method and Description |
---|---|
MaybeSource<T> |
HasUpstreamMaybeSource.source()
Returns the upstream source of this Maybe.
|
Modifier and Type | Class and Description |
---|---|
class |
FlowableElementAtMaybe<T> |
class |
FlowableLastMaybe<T>
Consumes the source Publisher and emits its last item or completes.
|
class |
FlowableReduceMaybe<T>
Reduce a Flowable into a single value exposed as Single or signal NoSuchElementException.
|
class |
FlowableSingleMaybe<T> |
Constructor and Description |
---|
FlowableConcatWithMaybe(Flowable<T> source,
MaybeSource<? extends T> other) |
FlowableMergeWithMaybe(Flowable<T> source,
MaybeSource<? extends T> other) |
Constructor and Description |
---|
FlowableFlatMapMaybe(Flowable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayError,
int maxConcurrency) |
Modifier and Type | Class and Description |
---|---|
class |
MaybeAmb<T>
Signals the event of the first MaybeSource that signals.
|
class |
MaybeCache<T>
Consumes the source once and replays its signal to any current or future MaybeObservers.
|
class |
MaybeCreate<T>
Provides an API over MaybeObserver that serializes calls to onXXX and manages cancellation
in a safe manner.
|
class |
MaybeDefer<T>
Defers the creation of the actual Maybe the incoming MaybeObserver is subscribed to.
|
class |
MaybeDelay<T>
Delays all signal types by the given amount and re-emits them on the given scheduler.
|
class |
MaybeDelayOtherPublisher<T,U>
Delay the emission of the main signal until the other signals an item or completes.
|
class |
MaybeDelaySubscriptionOtherPublisher<T,U>
Delay the subscription to the main Maybe until the other signals an item or completes.
|
class |
MaybeDelayWithCompletable<T> |
class |
MaybeDetach<T>
Breaks the references between the upstream and downstream when the Maybe terminates.
|
class |
MaybeDoAfterSuccess<T>
Calls a consumer after pushing the current item to the downstream.
|
class |
MaybeDoFinally<T>
Execute an action after an onSuccess, onError, onComplete or a dispose event.
|
class |
MaybeDoOnEvent<T>
Calls a BiConsumer with the success, error values of the upstream Maybe or with two nulls if
the Maybe completed.
|
class |
MaybeEmpty
Signals an onComplete.
|
class |
MaybeError<T>
Signals a constant Throwable.
|
class |
MaybeErrorCallable<T>
Signals a Throwable returned by a Callable.
|
class |
MaybeFilter<T>
Filters the upstream via a predicate, returning the success item or completing if
the predicate returns false.
|
class |
MaybeFilterSingle<T>
Filters the upstream SingleSource via a predicate, returning the success item or completing if
the predicate returns false.
|
class |
MaybeFlatMapBiSelector<T,U,R>
Maps a source item to another MaybeSource then calls a BiFunction with the
original item and the secondary item to generate the final result.
|
class |
MaybeFlatMapNotification<T,R>
Maps a value into a MaybeSource and relays its signal.
|
class |
MaybeFlatMapSingleElement<T,R>
Maps the success value of the source MaybeSource into a Single.
|
class |
MaybeFlatten<T,R>
Maps a value into a MaybeSource and relays its signal.
|
class |
MaybeFromAction<T>
Executes an Action and signals its exception or completes normally.
|
class |
MaybeFromCallable<T>
Executes a callable and signals its value as success or signals an exception.
|
class |
MaybeFromCompletable<T>
Wrap a Single into a Maybe.
|
class |
MaybeFromFuture<T>
Waits until the source Future completes or the wait times out; treats a
null
result as indication to signal onComplete instead of onSuccess . |
class |
MaybeFromRunnable<T>
Executes an Runnable and signals its exception or completes normally.
|
class |
MaybeFromSingle<T>
Wrap a Single into a Maybe.
|
class |
MaybeHide<T>
Hides the identity of the upstream Maybe and its Disposable sent through onSubscribe.
|
class |
MaybeIgnoreElement<T>
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
|
class |
MaybeIsEmpty<T>
Signals true if the source Maybe signals onComplete, signals false if the source Maybe
signals onSuccess.
|
class |
MaybeJust<T>
Signals a constant value.
|
class |
MaybeLift<T,R>
Calls a MaybeOperator for the incoming MaybeObserver.
|
class |
MaybeMap<T,R>
Maps the upstream success value into some other value.
|
class |
MaybeNever
Doesn't signal any event other than onSubscribe.
|
class |
MaybeObserveOn<T>
Signals the onSuccess, onError or onComplete events on a the specific scheduler.
|
class |
MaybeOnErrorComplete<T>
Emits an onComplete if the source emits an onError and the predicate returns true for
that Throwable.
|
class |
MaybeOnErrorNext<T>
Subscribes to the MaybeSource returned by a function if the main source signals an onError.
|
class |
MaybeOnErrorReturn<T>
Returns a value generated via a function if the main source signals an onError.
|
class |
MaybePeek<T>
Peeks into the lifecycle of a Maybe and MaybeObserver.
|
class |
MaybeSubscribeOn<T>
Subscribes to the upstream MaybeSource on the specified scheduler.
|
class |
MaybeSwitchIfEmpty<T>
Subscribes to the other source if the main source is empty.
|
class |
MaybeTakeUntilMaybe<T,U>
Relays the main source's event unless the other Maybe signals an item first or just completes
at which point the resulting Maybe is completed.
|
class |
MaybeTakeUntilPublisher<T,U>
Relays the main source's event unless the other Publisher signals an item first or just completes
at which point the resulting Maybe is completed.
|
class |
MaybeTimeoutMaybe<T,U>
Switches to the fallback Maybe if the other MaybeSource signals a success or completes, or
signals TimeoutException if fallback is null.
|
class |
MaybeTimeoutPublisher<T,U>
Switches to the fallback Maybe if the other Publisher signals a success or completes, or
signals TimeoutException if fallback is null.
|
class |
MaybeTimer
Signals a
0L after the specified delay. |
class |
MaybeUnsafeCreate<T>
Wraps a MaybeSource without safeguard and calls its subscribe() method for each MaybeObserver.
|
class |
MaybeUnsubscribeOn<T>
Makes sure a dispose() call from downstream happens on the specified scheduler.
|
class |
MaybeUsing<T,D>
Creates a resource and a dependent Maybe for each incoming Observer and optionally
disposes the resource eagerly (before the terminal event is send out).
|
class |
MaybeZipArray<T,R> |
class |
MaybeZipIterable<T,R> |
Modifier and Type | Method and Description |
---|---|
MaybeSource<T> |
MaybeToSingle.source() |
MaybeSource<T> |
MaybeCount.source() |
MaybeSource<T> |
MaybeToFlowable.source() |
MaybeSource<T> |
MaybeSwitchIfEmptySingle.source() |
MaybeSource<T> |
MaybeIsEmptySingle.source() |
MaybeSource<T> |
MaybeContains.source() |
MaybeSource<T> |
MaybeToObservable.source() |
Modifier and Type | Method and Description |
---|---|
static <T> Function<MaybeSource<T>,org.reactivestreams.Publisher<T>> |
MaybeToPublisher.instance() |
Modifier and Type | Method and Description |
---|---|
org.reactivestreams.Publisher<Object> |
MaybeToPublisher.apply(MaybeSource<Object> t) |
Constructor and Description |
---|
MaybeAmb(MaybeSource<? extends T>[] sources,
Iterable<? extends MaybeSource<? extends T>> sourcesIterable) |
MaybeConcatIterable(Iterable<? extends MaybeSource<? extends T>> sources) |
MaybeDefer(Callable<? extends MaybeSource<? extends T>> maybeSupplier) |
MaybeFlatMapBiSelector(MaybeSource<T> source,
Function<? super T,? extends MaybeSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> resultSelector) |
MaybeFlatMapNotification(MaybeSource<T> source,
Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier) |
MaybeFlatMapNotification(MaybeSource<T> source,
Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier) |
MaybeFlatMapNotification(MaybeSource<T> source,
Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier) |
MaybeFlatten(MaybeSource<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper) |
MaybeOnErrorNext(MaybeSource<T> source,
Function<? super Throwable,? extends MaybeSource<? extends T>> resumeFunction,
boolean allowFatal) |
MaybeUsing(Callable<? extends D> resourceSupplier,
Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
Consumer<? super D> resourceDisposer,
boolean eager) |
MaybeZipIterable(Iterable<? extends MaybeSource<? extends T>> sources,
Function<? super Object[],? extends R> zipper) |
Constructor and Description |
---|
MaybeFlatMapObservable(MaybeSource<T> source,
Function<? super T,? extends ObservableSource<? extends R>> mapper) |
MaybeFlatMapPublisher(MaybeSource<T> source,
Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper) |
Constructor and Description |
---|
FlowableConcatMapMaybe(Flowable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
ErrorMode errorMode,
int prefetch) |
FlowableSwitchMapMaybe(Flowable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors) |
ObservableConcatMapMaybe(Observable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
ErrorMode errorMode,
int prefetch) |
ObservableSwitchMapMaybe(Observable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors) |
Modifier and Type | Class and Description |
---|---|
class |
ObservableElementAtMaybe<T> |
class |
ObservableLastMaybe<T>
Consumes the source ObservableSource and emits its last item, the defaultItem
if empty or a NoSuchElementException if even the defaultItem is null.
|
class |
ObservableReduceMaybe<T>
Reduce a sequence of values into a single value via an aggregator function and emit the final value or complete
if the source is empty.
|
class |
ObservableSingleMaybe<T> |
Constructor and Description |
---|
ObservableConcatWithMaybe(Observable<T> source,
MaybeSource<? extends T> other) |
ObservableMergeWithMaybe(Observable<T> source,
MaybeSource<? extends T> other) |
Constructor and Description |
---|
ObservableFlatMapMaybe(ObservableSource<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayError) |
Modifier and Type | Class and Description |
---|---|
class |
SingleFlatMapMaybe<T,R> |
Constructor and Description |
---|
SingleFlatMapMaybe(SingleSource<? extends T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper) |
Modifier and Type | Class and Description |
---|---|
class |
MaybeSubject<T>
Represents a hot Maybe-like source and consumer of events similar to Subjects.
|
Copyright © 2018 JBoss by Red Hat. All rights reserved.