Package | Description |
---|---|
io.reactivex |
Base reactive classes:
Flowable , Observable ,
Single , Maybe and
Completable ; base reactive consumers;
other common base interfaces. |
io.reactivex.annotations |
Annotations for indicating experimental and beta operators, classes, methods, types or fields.
|
io.reactivex.flowables |
Classes supporting the Flowable base reactive class:
ConnectableFlowable and
GroupedFlowable . |
io.reactivex.internal.operators.completable | |
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.internal.schedulers | |
io.reactivex.observables |
Classes supporting the Observable base reactive class:
ConnectableObservable and
GroupedObservable . |
io.reactivex.observers |
Default wrappers and implementations for Observer-based consumer classes and interfaces,
including disposable and resource-tracking variants and
the
TestObserver that allows unit testing
Observable -, Single -, Maybe -
and Completable -based flows. |
io.reactivex.parallel |
Contains the base type
ParallelFlowable ,
a sub-DSL for working with Flowable sequences in parallel. |
io.reactivex.processors |
Classes extending the Flowable base reactive class and implementing
the Subscriber interface at the same time (aka hot Flowables).
|
io.reactivex.schedulers |
Scheduler implementations, value+time record class and the standard factory class to
return standard RxJava schedulers or wrap any Executor-based (thread pool) instances.
|
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 | Interface and Description |
---|---|
interface |
CompletableConverter<R>
Convenience interface and callback used by the
Completable.as(io.reactivex.CompletableConverter<? extends R>) operator to turn a Completable into another
value fluently. |
interface |
FlowableConverter<T,R>
Convenience interface and callback used by the
Flowable.as(io.reactivex.FlowableConverter<T, ? extends R>) operator to turn a Flowable into another
value fluently. |
interface |
MaybeConverter<T,R>
Convenience interface and callback used by the
Maybe.as(io.reactivex.MaybeConverter<T, ? extends R>) operator to turn a Maybe into another
value fluently. |
interface |
ObservableConverter<T,R>
Convenience interface and callback used by the
Observable.as(io.reactivex.ObservableConverter<T, ? extends R>) operator to turn an Observable into another
value fluently. |
interface |
SingleConverter<T,R>
Convenience interface and callback used by the
Single.as(io.reactivex.SingleConverter<T, ? extends R>) operator to turn a Single into another
value fluently. |
Modifier and Type | Method and Description |
---|---|
<R> R |
Completable.as(CompletableConverter<? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Flowable.as(FlowableConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Maybe.as(MaybeConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Observable.as(ObservableConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Single.as(SingleConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
int bufferSize)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
int bufferSize)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
int bufferSize)
Subscribes to the source and calls the given callbacks on the current thread.
|
Completable |
Flowable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other completes. |
Completable |
Observable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in
order and waits until the upstream and all CompletableSources complete.
|
Completable |
Flowable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
int prefetch)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other completes. |
Completable |
Observable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
int capacityHint)
Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in
order and waits until the upstream and all CompletableSources complete.
|
Completable |
Flowable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, delaying all errors till both this Flowable and all
inner CompletableSource s terminate. |
Completable |
Observable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, delaying all errors till both this Observable and all
inner CompletableSource s terminate. |
Completable |
Flowable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Flowable and all
inner CompletableSource s terminate. |
Completable |
Observable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Observable and all
inner CompletableSource s terminate. |
Completable |
Flowable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Flowable and all
inner CompletableSource s terminate. |
Completable |
Observable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Observable and all
inner CompletableSource s terminate. |
<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. |
<R> Flowable<R> |
Flowable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Flowable or the current inner SingleSource fail. |
<R> Observable<R> |
Observable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Observable or the current inner SingleSource fail. |
<R> Flowable<R> |
Flowable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Flowable or the current inner SingleSource fail. |
<R> Observable<R> |
Observable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Observable or the current inner SingleSource fail. |
<R> Flowable<R> |
Flowable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and delays all errors
till both this Flowable and all inner SingleSource s terminate. |
<R> Observable<R> |
Observable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and delays all errors
till both this Observable and all inner SingleSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays all errors
till both this Flowable and all inner SingleSource s terminate. |
<R> Observable<R> |
Observable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays all errors
till both this Observable and all inner SingleSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays errors
till both this Flowable and all inner SingleSource s terminate. |
<R> Observable<R> |
Observable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays errors
till both this Observable and all inner SingleSource s terminate. |
Flowable<T> |
Flowable.concatWith(CompletableSource other)
Returns a
Flowable that emits items from this Flowable and when it completes normally, the
other CompletableSource is subscribed to and the returned Flowable emits its terminal events. |
Observable<T> |
Observable.concatWith(CompletableSource other)
Returns an
Observable that emits items from this Observable and when it completes normally, the
other CompletableSource is subscribed to and the returned Observable emits its terminal events. |
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 . |
Flowable<T> |
Flowable.concatWith(SingleSource<? extends T> other)
Returns a
Flowable that emits the items from this Flowable followed by the success item or error event
of the other SingleSource . |
Observable<T> |
Observable.concatWith(SingleSource<? extends T> other)
Returns an
Observable that emits the items from this Observable followed by the success item or error event
of the other SingleSource . |
Single<T> |
Single.delay(long time,
TimeUnit unit,
boolean delayError)
Delays the emission of the success or error signal from the current Single by the specified amount.
|
Single<T> |
Single.delay(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Delays the emission of the success or error signal from the current Single by the specified amount.
|
Flowable<T> |
Flowable.limit(long count)
Limits both the number of upstream items (after which the sequence completes)
and the total downstream request amount requested from the upstream to
possibly prevent the creation of excess items by the upstream.
|
static <T> Flowable<T> |
Single.mergeDelayError(Iterable<? extends SingleSource<? extends T>> sources)
Merges an Iterable sequence of SingleSource instances into a single Flowable sequence,
running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
|
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.
|
static <T> Flowable<T> |
Single.mergeDelayError(org.reactivestreams.Publisher<? extends SingleSource<? extends T>> sources)
Merges a Flowable sequence of SingleSource instances into a single Flowable sequence,
running all SingleSources at once and delaying any error(s) until all sources succeed or fail.
|
static <T> Flowable<T> |
Single.mergeDelayError(SingleSource<? extends T> source1,
SingleSource<? extends T> source2)
Flattens two Singles into a single Flowable, without any transformation, delaying
any error(s) until all sources succeed or fail.
|
static <T> Flowable<T> |
Single.mergeDelayError(SingleSource<? extends T> source1,
SingleSource<? extends T> source2,
SingleSource<? extends T> source3)
Flattens three Singles into a single Flowable, without any transformation, delaying
any error(s) until all sources succeed or fail.
|
static <T> Flowable<T> |
Single.mergeDelayError(SingleSource<? extends T> source1,
SingleSource<? extends T> source2,
SingleSource<? extends T> source3,
SingleSource<? extends T> source4)
Flattens four Singles into a single Flowable, without any transformation, delaying
any error(s) until all sources succeed or fail.
|
Flowable<T> |
Flowable.mergeWith(CompletableSource other)
Relays the items of this Flowable and completes only when the other CompletableSource completes
as well.
|
Observable<T> |
Observable.mergeWith(CompletableSource other)
Relays the items of this Observable and completes only when the other CompletableSource completes
as well.
|
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.
|
Flowable<T> |
Flowable.mergeWith(SingleSource<? extends T> other)
Merges the sequence of items of this Flowable with the success value of the other SingleSource.
|
Observable<T> |
Observable.mergeWith(SingleSource<? extends T> other)
Merges the sequence of items of this Observable with the success value of the other SingleSource.
|
Completable |
Completable.onTerminateDetach()
Nulls out references to the upstream producer and downstream CompletableObserver if
the sequence is terminated or downstream calls dispose().
|
Single<T> |
Single.onTerminateDetach()
Nulls out references to the upstream producer and downstream SingleObserver if
the sequence is terminated or downstream calls dispose().
|
Completable |
Completable.retry(long times,
Predicate<? super Throwable> predicate)
Returns a Completable that when this Completable emits an error, retries at most times
or until the predicate returns false, whichever happens first and emitting the last error.
|
Single<T> |
Single.retry(long times,
Predicate<? super Throwable> predicate)
Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first
if it fails with an onError.
|
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler,
boolean requestOn)
|
Single<T> |
Maybe.switchIfEmpty(SingleSource<? extends T> other)
Returns a Single that emits the items emitted by the source Maybe or the item of an alternate
SingleSource if the current Maybe is empty.
|
Completable |
Flowable.switchMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
Completable |
Observable.switchMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
Completable |
Flowable.switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running and delaying any main or inner errors until all
of them terminate. |
Completable |
Observable.switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running and delaying any main or inner errors until all
of them terminate. |
<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. |
<R> Flowable<R> |
Flowable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource 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
while failing immediately if this Flowable or any of the
active inner SingleSource s fail. |
<R> Observable<R> |
Observable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted
of these SingleSources.
|
<R> Flowable<R> |
Flowable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource 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,
delaying errors from this Flowable or the inner SingleSource s until all terminate. |
<R> Observable<R> |
Observable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted
of these SingleSources and delays any error until all SingleSources terminate.
|
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit,
boolean emitLast)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit,
boolean emitLast)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
boolean |
FlowableEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
SingleEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
CompletableEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
MaybeEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
boolean |
ObservableEmitter.tryOnError(Throwable t)
Attempts to emit the specified
Throwable error if the downstream
hasn't cancelled the sequence or is otherwise terminated, returning false
if the emission is not allowed to happen due to lifecycle restrictions. |
Single<T> |
Single.unsubscribeOn(Scheduler scheduler)
Returns a Single which makes sure when a SingleObserver disposes the Disposable,
that call is propagated up on the specified scheduler.
|
Modifier and Type | Field and Description |
---|---|
static String |
SchedulerSupport.SINGLE
The operator/class runs on RxJava's single scheduler
or takes timing information from it.
|
Modifier and Type | Method and Description |
---|---|
Flowable<T> |
ConnectableFlowable.refCount(int subscriberCount)
Connects to the upstream
ConnectableFlowable if the number of subscribed
subscriber reaches the specified count and disconnect if all subscribers have unsubscribed. |
Flowable<T> |
ConnectableFlowable.refCount(int subscriberCount,
long timeout,
TimeUnit unit)
Connects to the upstream
ConnectableFlowable if the number of subscribed
subscriber reaches the specified count and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Flowable<T> |
ConnectableFlowable.refCount(int subscriberCount,
long timeout,
TimeUnit unit,
Scheduler scheduler)
Connects to the upstream
ConnectableFlowable if the number of subscribed
subscriber reaches the specified count and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Flowable<T> |
ConnectableFlowable.refCount(long timeout,
TimeUnit unit)
Connects to the upstream
ConnectableFlowable if the number of subscribed
subscriber reaches 1 and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Flowable<T> |
ConnectableFlowable.refCount(long timeout,
TimeUnit unit,
Scheduler scheduler)
Connects to the upstream
ConnectableFlowable if the number of subscribed
subscriber reaches 1 and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Modifier and Type | Class and Description |
---|---|
class |
CompletableCache
Consume the upstream source exactly once and cache its terminal event.
|
class |
CompletableDetach
Breaks the references between the upstream and downstream when the Completable terminates.
|
class |
CompletableDoFinally
Execute an action after an onError, onComplete or a dispose event.
|
Modifier and Type | Class and Description |
---|---|
class |
FlowableDoAfterNext<T>
Calls a consumer after pushing the current item to the downstream.
|
class |
FlowableDoFinally<T>
Execute an action after an onError, onComplete or a cancel event.
|
class |
FlowableLimit<T>
Limits both the total request amount and items received from the upstream.
|
class |
FlowableThrottleLatest<T>
Emits the next or latest item when the given time elapses.
|
Modifier and Type | Class and Description |
---|---|
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 |
MaybeFlatMapSingleElement<T,R>
Maps the success value of the source MaybeSource into a Single.
|
Modifier and Type | Method and Description |
---|---|
static <T> MaybeObserver<T> |
MaybeToObservable.create(Observer<? super T> downstream)
Creates a
MaybeObserver wrapper around a Observer . |
Modifier and Type | Class and Description |
---|---|
class |
FlowableConcatMapCompletable<T>
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other completes or terminates (in error-delaying mode). |
class |
FlowableConcatMapMaybe<T,R>
Maps each upstream item into a
MaybeSource , subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate. |
class |
FlowableConcatMapSingle<T,R>
Maps each upstream item into a
SingleSource , subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate. |
class |
FlowableSwitchMapCompletable<T>
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
class |
FlowableSwitchMapMaybe<T,R>
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value if available, optionally delaying
errors from the main source or the inner sources. |
class |
FlowableSwitchMapSingle<T,R>
Maps the upstream items into
SingleSource s and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value, optionally delaying
errors from the main source or the inner sources. |
class |
ObservableConcatMapCompletable<T>
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other completes or terminates (in error-delaying mode). |
class |
ObservableConcatMapMaybe<T,R>
Maps each upstream item into a
MaybeSource , subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate. |
class |
ObservableConcatMapSingle<T,R>
Maps each upstream item into a
SingleSource , subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate. |
class |
ObservableSwitchMapCompletable<T>
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
class |
ObservableSwitchMapMaybe<T,R>
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value if available, optionally delaying
errors from the main source or the inner sources. |
class |
ObservableSwitchMapSingle<T,R>
Maps the upstream items into
SingleSource s and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value if available, optionally delaying
errors from the main source or the inner sources. |
Modifier and Type | Class and Description |
---|---|
class |
ObservableDoAfterNext<T>
Calls a consumer after pushing the current item to the downstream.
|
class |
ObservableDoFinally<T>
Execute an action after an onError, onComplete or a dispose event.
|
class |
ObservableThrottleLatest<T>
Emits the next or latest item when the given time elapses.
|
Modifier and Type | Class and Description |
---|---|
class |
SingleDetach<T>
Breaks the references between the upstream and downstream when the Maybe terminates.
|
class |
SingleDoAfterSuccess<T>
Calls a consumer after pushing the current item to the downstream.
|
class |
SingleDoFinally<T>
Execute an action after an onSuccess, onError or a dispose event.
|
Modifier and Type | Method and Description |
---|---|
static <T> SingleObserver<T> |
SingleToObservable.create(Observer<? super T> downstream)
Creates a
SingleObserver wrapper around a Observer . |
Modifier and Type | Interface and Description |
---|---|
interface |
SchedulerMultiWorkerSupport
Allows retrieving multiple workers from the implementing
Scheduler in a way that when asking for
at most the parallelism level of the Scheduler, those
Scheduler.Worker instances will be running
with different backing threads. |
class |
SchedulerWhen
Allows the use of operators for controlling the timing around when actions
scheduled on workers are actually done.
|
Modifier and Type | Method and Description |
---|---|
Observable<T> |
ConnectableObservable.refCount(int subscriberCount)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches the specified count and disconnect if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(int subscriberCount,
long timeout,
TimeUnit unit)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches the specified count and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(int subscriberCount,
long timeout,
TimeUnit unit,
Scheduler scheduler)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches the specified count and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(long timeout,
TimeUnit unit)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches 1 and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(long timeout,
TimeUnit unit,
Scheduler scheduler)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches 1 and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Modifier and Type | Interface and Description |
---|---|
interface |
LambdaConsumerIntrospection
An interface that indicates that the implementing type is composed of individual components and exposes information
about their behavior.
|
Modifier and Type | Method and Description |
---|---|
U |
BaseTestConsumer.assertValueAt(int index,
T value)
Asserts that this TestObserver/TestSubscriber received an onNext value at the given index
which is equal to the given value with respect to null-safe Object.equals.
|
U |
BaseTestConsumer.assertValueSequenceOnly(Iterable<? extends T> sequence)
Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating.
|
U |
BaseTestConsumer.assertValueSetOnly(Collection<? extends T> expected)
Assert that the TestObserver/TestSubscriber received only the specified values in any order without terminating.
|
U |
BaseTestConsumer.assertValuesOnly(T... values)
Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating.
|
boolean |
LambdaConsumerIntrospection.hasCustomOnError() |
Modifier and Type | Class and Description |
---|---|
class |
ParallelFailureHandling
Enumerations for handling failure within a parallel operator.
|
interface |
ParallelFlowableConverter<T,R>
Convenience interface and callback used by the
ParallelFlowable.as(io.reactivex.parallel.ParallelFlowableConverter<T, R>) operator to turn a ParallelFlowable into
another value fluently. |
interface |
ParallelTransformer<Upstream,Downstream>
Interface to compose ParallelFlowable.
|
Modifier and Type | Method and Description |
---|---|
<R> R |
ParallelFlowable.as(ParallelFlowableConverter<T,R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.doOnNext(Consumer<? super T> onNext,
ParallelFailureHandling errorHandler)
Call the specified consumer with the current element passing through any 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Filters the source values on each 'rail' and
handles errors based on the returned value by the handler function.
|
ParallelFlowable<T> |
ParallelFlowable.filter(Predicate<? super T> predicate,
ParallelFailureHandling errorHandler)
Filters the source values on each 'rail' and
handles errors based on the given
ParallelFailureHandling enumeration value. |
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the returned value by the handler function.
|
<R> ParallelFlowable<R> |
ParallelFlowable.map(Function<? super T,? extends R> mapper,
ParallelFailureHandling errorHandler)
Maps the source values on each 'rail' to another value and
handles errors based on the given
ParallelFailureHandling enumeration value. |
Flowable<T> |
ParallelFlowable.sequentialDelayError()
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Flowable sequence, running with a default prefetch value
for the rails and delaying errors from all rails till all terminate.
|
Modifier and Type | Class and Description |
---|---|
class |
MulticastProcessor<T>
A
FlowableProcessor implementation that coordinates downstream requests through
a front-buffer and stable-prefetching, optionally canceling the upstream if all
subscribers have cancelled. |
Modifier and Type | Method and Description |
---|---|
void |
ReplayProcessor.cleanupBuffer()
Makes sure the item cached by the head node in a bounded
ReplayProcessor is released (as it is never part of a replay).
|
static <T> UnicastProcessor<T> |
UnicastProcessor.create(boolean delayError)
Creates an UnicastProcessor with default internal buffer capacity hint and delay error flag.
|
static <T> UnicastProcessor<T> |
UnicastProcessor.create(int capacityHint,
Runnable onCancelled,
boolean delayError)
Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for
the case when the single Subscriber cancels its subscription.
|
boolean |
BehaviorProcessor.offer(T t)
Tries to emit the item to all currently subscribed Subscribers if all of them
has requested some value, returns false otherwise.
|
boolean |
PublishProcessor.offer(T t)
Tries to emit the item to all currently subscribed Subscribers if all of them
has requested some value, returns false otherwise.
|
Modifier and Type | Interface and Description |
---|---|
interface |
SchedulerRunnableIntrospection
Interface to indicate the implementor class wraps a
Runnable that can
be accessed via SchedulerRunnableIntrospection.getWrappedRunnable() . |
Modifier and Type | Method and Description |
---|---|
void |
ReplaySubject.cleanupBuffer()
Makes sure the item cached by the head node in a bounded
ReplaySubject is released (as it is never part of a replay).
|
static <T> UnicastSubject<T> |
UnicastSubject.create(boolean delayError)
Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.
|
static <T> UnicastSubject<T> |
UnicastSubject.create(int capacityHint,
Runnable onTerminate,
boolean delayError)
Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and
a callback for the case when the single Subscriber cancels its subscription.
|
Copyright © 2018 JBoss by Red Hat. All rights reserved.