Package | Description |
---|---|
io.reactivex |
Base reactive classes:
Flowable , Observable ,
Single , Maybe and
Completable ; base reactive consumers;
other common base interfaces. |
io.reactivex.flowables |
Classes supporting the Flowable base reactive class:
ConnectableFlowable and
GroupedFlowable . |
io.reactivex.internal.fuseable |
Base interfaces and types for supporting operator-fusion.
|
io.reactivex.internal.operators.completable | |
io.reactivex.internal.operators.flowable | |
io.reactivex.internal.operators.maybe | |
io.reactivex.internal.operators.mixed | |
io.reactivex.internal.operators.parallel | |
io.reactivex.internal.operators.single | |
io.reactivex.internal.schedulers | |
io.reactivex.parallel |
Contains the base type
ParallelFlowable ,
a sub-DSL for working with Flowable sequences in parallel. |
io.reactivex.plugins |
Contains the central plugin handler
RxJavaPlugins
class to hook into the lifecycle of the base reactive types and schedulers. |
io.reactivex.processors |
Classes extending the Flowable base reactive class and implementing
the Subscriber interface at the same time (aka hot Flowables).
|
Modifier and Type | Method and Description |
---|---|
static <T> Flowable<T> |
Flowable.amb(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends
a termination notification.
|
static <T> Flowable<T> |
Flowable.ambArray(org.reactivestreams.Publisher<? extends T>... sources)
Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends
a termination notification.
|
Flowable<T> |
Flowable.ambWith(org.reactivestreams.Publisher<? extends T> other)
Mirrors the Publisher (current or provided) that first either emits an item or sends a termination
notification.
|
<T> Flowable<T> |
Completable.andThen(org.reactivestreams.Publisher<T> next)
Returns a Flowable which will subscribe to this Completable and once that is completed then
will subscribe to the
next Flowable. |
<B> Flowable<List<T>> |
Flowable.buffer(Callable<? extends org.reactivestreams.Publisher<B>> boundaryIndicatorSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<B,U extends Collection<? super T>> |
Flowable.buffer(Callable<? extends org.reactivestreams.Publisher<B>> boundaryIndicatorSupplier,
Callable<U> bufferSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<TOpening,TClosing> |
Flowable.buffer(Flowable<? extends TOpening> openingIndicator,
Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> closingIndicator)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<TOpening,TClosing,U extends Collection<? super T>> |
Flowable.buffer(Flowable<? extends TOpening> openingIndicator,
Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> closingIndicator,
Callable<U> bufferSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(int count)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<U extends Collection<? super T>> |
Flowable.buffer(int count,
Callable<U> bufferSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(int count,
int skip)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<U extends Collection<? super T>> |
Flowable.buffer(int count,
int skip,
Callable<U> bufferSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
long timeskip,
TimeUnit unit)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<U extends Collection<? super T>> |
Flowable.buffer(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
Callable<U> bufferSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
TimeUnit unit)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
TimeUnit unit,
int count)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
TimeUnit unit,
Scheduler scheduler,
int count)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<U extends Collection<? super T>> |
Flowable.buffer(long timespan,
TimeUnit unit,
Scheduler scheduler,
int count,
Callable<U> bufferSupplier,
boolean restartTimerOnMaxSize)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<B> Flowable<List<T>> |
Flowable.buffer(org.reactivestreams.Publisher<B> boundaryIndicator)
Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the
specified boundary Publisher emits an item.
|
<B,U extends Collection<? super T>> |
Flowable.buffer(org.reactivestreams.Publisher<B> boundaryIndicator,
Callable<U> bufferSupplier)
Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the
specified boundary Publisher emits an item.
|
<B> Flowable<List<T>> |
Flowable.buffer(org.reactivestreams.Publisher<B> boundaryIndicator,
int initialCapacity)
Returns a Flowable that emits non-overlapping buffered items from the source Publisher each time the
specified boundary Publisher emits an item.
|
Flowable<T> |
Flowable.cache()
Returns a Flowable that subscribes to this Publisher lazily, caches all of its events
and replays them, in the same order as received, to all the downstream subscribers.
|
Flowable<T> |
Flowable.cacheWithInitialCapacity(int initialCapacity)
Returns a Flowable that subscribes to this Publisher lazily, caches all of its events
and replays them, in the same order as received, to all the downstream subscribers.
|
<U> Flowable<U> |
Flowable.cast(Class<U> clazz)
Returns a Flowable that emits the items emitted by the source Publisher, converted to the specified
type.
|
static <T,R> Flowable<R> |
Flowable.combineLatest(Function<? super Object[],? extends R> combiner,
org.reactivestreams.Publisher<? extends T>... sources)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T,R> Flowable<R> |
Flowable.combineLatest(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T,R> Flowable<R> |
Flowable.combineLatest(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T,R> Flowable<R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T>[] sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T,R> Flowable<R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T>[] sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,R> Flowable<R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> combiner)
Combines two source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from either of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
Function3<? super T1,? super T2,? super T3,? extends R> combiner)
Combines three source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)
Combines four source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)
Combines five source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)
Combines six source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)
Combines seven source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
org.reactivestreams.Publisher<? extends T8> source8,
Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> combiner)
Combines eight source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Flowable.combineLatest(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
org.reactivestreams.Publisher<? extends T8> source8,
org.reactivestreams.Publisher<? extends T9> source9,
Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> combiner)
Combines nine source Publishers by emitting an item that aggregates the latest values of each of the
source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T,R> Flowable<R> |
Flowable.combineLatestDelayError(Function<? super Object[],? extends R> combiner,
int bufferSize,
org.reactivestreams.Publisher<? extends T>... sources)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publisher, where this
aggregation is defined by a specified function and delays any error from the sources until
all source Publishers terminate.
|
static <T,R> Flowable<R> |
Flowable.combineLatestDelayError(Function<? super Object[],? extends R> combiner,
org.reactivestreams.Publisher<? extends T>... sources)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function and delays any error from the sources until
all source Publishers terminate.
|
static <T,R> Flowable<R> |
Flowable.combineLatestDelayError(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function and delays any error from the sources until
all source Publishers terminate.
|
static <T,R> Flowable<R> |
Flowable.combineLatestDelayError(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function and delays any error from the sources until
all source Publishers terminate.
|
static <T,R> Flowable<R> |
Flowable.combineLatestDelayError(org.reactivestreams.Publisher<? extends T>[] sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function.
|
static <T,R> Flowable<R> |
Flowable.combineLatestDelayError(org.reactivestreams.Publisher<? extends T>[] sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of
the source Publishers each time an item is received from any of the source Publishers, where this
aggregation is defined by a specified function and delays any error from the sources until
all source Publishers terminate.
|
<R> Flowable<R> |
Flowable.compose(FlowableTransformer<? super T,? extends R> composer)
Transform a Publisher by applying a particular Transformer function to it.
|
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> |
Flowable.concat(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence
of elements without interleaving them.
|
static <T> Flowable<T> |
Single.concat(Iterable<? extends SingleSource<? extends T>> sources)
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by
an Iterable sequence.
|
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,
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(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> |
Flowable.concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source
Publisher, one after the other, without interleaving them.
|
static <T> Flowable<T> |
Flowable.concat(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int prefetch)
Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source
Publisher, one after the other, without interleaving them.
|
static <T> Flowable<T> |
Single.concat(org.reactivestreams.Publisher<? extends SingleSource<? extends T>> sources)
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by
a Publisher sequence.
|
static <T> Flowable<T> |
Single.concat(org.reactivestreams.Publisher<? extends SingleSource<? extends T>> sources,
int prefetch)
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by
a Publisher sequence and prefetched by the specified amount.
|
static <T> Flowable<T> |
Flowable.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Returns a Flowable that emits the items emitted by two Publishers, one after the other, without
interleaving them.
|
static <T> Flowable<T> |
Flowable.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3)
Returns a Flowable that emits the items emitted by three Publishers, one after the other, without
interleaving them.
|
static <T> Flowable<T> |
Flowable.concat(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4)
Returns a Flowable that emits the items emitted by four Publishers, one after the other, without
interleaving them.
|
static <T> Flowable<T> |
Single.concat(SingleSource<? extends T> source1,
SingleSource<? extends T> source2)
Returns a Flowable that emits the items emitted by two Singles, one after the other.
|
static <T> Flowable<T> |
Single.concat(SingleSource<? extends T> source1,
SingleSource<? extends T> source2,
SingleSource<? extends T> source3)
Returns a Flowable that emits the items emitted by three Singles, one after the other.
|
static <T> Flowable<T> |
Single.concat(SingleSource<? extends T> source1,
SingleSource<? extends T> source2,
SingleSource<? extends T> source3,
SingleSource<? extends T> source4)
Returns a Flowable that emits the items emitted by four Singles, 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> |
Flowable.concatArray(org.reactivestreams.Publisher<? extends T>... sources)
Concatenates a variable number of Publisher sources.
|
static <T> Flowable<T> |
Single.concatArray(SingleSource<? extends T>... sources)
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in
an 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> |
Flowable.concatArrayDelayError(org.reactivestreams.Publisher<? extends T>... sources)
Concatenates a variable number of Publisher sources and delays errors from any of them
till all terminate.
|
static <T> Flowable<T> |
Flowable.concatArrayEager(int maxConcurrency,
int prefetch,
org.reactivestreams.Publisher<? extends T>... sources)
Concatenates an array of Publishers eagerly into a single stream of values.
|
static <T> Flowable<T> |
Maybe.concatArrayEager(MaybeSource<? extends T>... sources)
Concatenates a sequence of MaybeSource eagerly into a single stream of values.
|
static <T> Flowable<T> |
Flowable.concatArrayEager(org.reactivestreams.Publisher<? extends T>... sources)
Concatenates an array of Publishers eagerly into a single stream of values.
|
static <T> Flowable<T> |
Single.concatArrayEager(SingleSource<? extends T>... sources)
Concatenates a sequence of SingleSource eagerly into a single stream of values.
|
static <T> Flowable<T> |
Flowable.concatArrayEagerDelayError(int maxConcurrency,
int prefetch,
org.reactivestreams.Publisher<? extends T>... sources)
Concatenates an array of
Publisher s eagerly into a single stream of values
and delaying any errors until all sources terminate. |
static <T> Flowable<T> |
Flowable.concatArrayEagerDelayError(org.reactivestreams.Publisher<? extends T>... sources)
Concatenates an array of
Publisher s eagerly into a single stream of values
and delaying any errors until all sources terminate. |
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> |
Flowable.concatDelayError(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher,
one after the other, one at a time and delays any errors till the all inner Publishers 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> |
Flowable.concatDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? 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> |
Flowable.concatDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int prefetch,
boolean tillTheEnd)
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> |
Flowable.concatEager(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
Concatenates a sequence of Publishers eagerly into a single stream of values.
|
static <T> Flowable<T> |
Flowable.concatEager(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency,
int prefetch)
Concatenates a sequence of Publishers eagerly into a single stream of values.
|
static <T> Flowable<T> |
Single.concatEager(Iterable<? extends SingleSource<? extends T>> sources)
Concatenates a sequence of SingleSources 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.
|
static <T> Flowable<T> |
Flowable.concatEager(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
|
static <T> Flowable<T> |
Flowable.concatEager(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency,
int prefetch)
Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.
|
static <T> Flowable<T> |
Single.concatEager(org.reactivestreams.Publisher<? extends SingleSource<? extends T>> sources)
Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.
|
<R> Flowable<R> |
Flowable.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Returns a new Flowable that emits items resulting from applying a function that you supply to each item
emitted by the source Publisher, where that function returns a Publisher, and then emitting the items
that result from concatenating those resulting Publishers.
|
<R> Flowable<R> |
Flowable.concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch)
Returns a new Flowable that emits items resulting from applying a function that you supply to each item
emitted by the source Publisher, where that function returns a Publisher, and then emitting the items
that result from concatenating those resulting Publishers.
|
<R> Flowable<R> |
Flowable.concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Maps each of the items into a Publisher, subscribes to them one after the other,
one at a time and emits their values in order
while delaying any error from either this or any of the inner Publishers
till all of them terminate.
|
<R> Flowable<R> |
Flowable.concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch,
boolean tillTheEnd)
Maps each of the items into a Publisher, subscribes to them one after the other,
one at a time and emits their values in order
while delaying any error from either this or any of the inner Publishers
till all of them terminate.
|
<R> Flowable<R> |
Flowable.concatMapEager(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single
Publisher.
|
<R> Flowable<R> |
Flowable.concatMapEager(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int maxConcurrency,
int prefetch)
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single
Publisher.
|
<R> Flowable<R> |
Flowable.concatMapEagerDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean tillTheEnd)
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single
Publisher.
|
<R> Flowable<R> |
Flowable.concatMapEagerDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int maxConcurrency,
int prefetch,
boolean tillTheEnd)
Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single
Publisher.
|
<U> Flowable<U> |
Flowable.concatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an
Iterable corresponding to that item that is generated by a selector.
|
<U> Flowable<U> |
Flowable.concatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper,
int prefetch)
Returns a Flowable that concatenate each item emitted by the source Publisher with the values in an
Iterable corresponding to that item that is generated by a selector.
|
<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> 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> 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> 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> 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> 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> 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> 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> 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> 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. |
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. |
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 . |
Flowable<T> |
Flowable.concatWith(org.reactivestreams.Publisher<? extends T> other)
Returns a Flowable that emits the items emitted from the current Publisher, then the next, one after
the other, without interleaving them.
|
Flowable<T> |
Single.concatWith(SingleSource<? extends T> other)
Returns a Flowable that emits the item emitted by the source Single, then the item emitted by the
specified Single.
|
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 . |
static <T> Flowable<T> |
Flowable.create(FlowableOnSubscribe<T> source,
BackpressureStrategy mode)
Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style,
generally non-backpressured world.
|
<U> Flowable<T> |
Flowable.debounce(Function<? super T,? extends org.reactivestreams.Publisher<U>> debounceIndicator)
Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the
source Publisher that are followed by another item within a computed debounce duration.
|
Flowable<T> |
Flowable.debounce(long timeout,
TimeUnit unit)
Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the
source Publisher that are followed by newer items before a timeout value expires.
|
Flowable<T> |
Flowable.debounce(long timeout,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the
source Publisher that are followed by newer items before a timeout value expires on a specified
Scheduler.
|
Flowable<T> |
Flowable.defaultIfEmpty(T defaultItem)
Returns a Flowable that emits the items emitted by the source Publisher or a specified default item
if the source Publisher is empty.
|
static <T> Flowable<T> |
Flowable.defer(Callable<? extends org.reactivestreams.Publisher<? extends T>> supplier)
Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber
that subscribes.
|
<U> Flowable<T> |
Flowable.delay(Function<? super T,? extends org.reactivestreams.Publisher<U>> itemDelayIndicator)
Returns a Flowable that delays the emissions of the source Publisher via another Publisher on a
per-item basis.
|
Flowable<T> |
Flowable.delay(long delay,
TimeUnit unit)
Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a
specified delay.
|
Flowable<T> |
Flowable.delay(long delay,
TimeUnit unit,
boolean delayError)
Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a
specified delay.
|
Flowable<T> |
Flowable.delay(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a
specified delay.
|
Flowable<T> |
Flowable.delay(long delay,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns a Flowable that emits the items emitted by the source Publisher shifted forward in time by a
specified delay.
|
<U,V> Flowable<T> |
Flowable.delay(org.reactivestreams.Publisher<U> subscriptionIndicator,
Function<? super T,? extends org.reactivestreams.Publisher<V>> itemDelayIndicator)
Returns a Flowable that delays the subscription to and emissions from the source Publisher via another
Publisher on a per-item basis.
|
Flowable<T> |
Flowable.delaySubscription(long delay,
TimeUnit unit)
Returns a Flowable that delays the subscription to the source Publisher by a given amount of time.
|
Flowable<T> |
Flowable.delaySubscription(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that delays the subscription to the source Publisher by a given amount of time,
both waiting and subscribing on a given Scheduler.
|
<U> Flowable<T> |
Flowable.delaySubscription(org.reactivestreams.Publisher<U> subscriptionIndicator)
Returns a Flowable that delays the subscription to this Publisher
until the other Publisher emits an element or completes normally.
|
<T2> Flowable<T2> |
Flowable.dematerialize()
Deprecated.
in 2.2.4; inherently type-unsafe as it overrides the output generic type. Use
dematerialize(Function) instead. |
<R> Flowable<R> |
Flowable.dematerialize(Function<? super T,Notification<R>> selector)
Returns a Flowable that reverses the effect of
materialize by transforming the
Notification objects extracted from the source items via a selector function
into their respective Subscriber signal types. |
Flowable<T> |
Flowable.distinct()
Returns a Flowable that emits all items emitted by the source Publisher that are distinct
based on
Object.equals(Object) comparison. |
<K> Flowable<T> |
Flowable.distinct(Function<? super T,K> keySelector)
Returns a Flowable that emits all items emitted by the source Publisher that are distinct according
to a key selector function and based on
Object.equals(Object) comparison of the objects
returned by the key selector function. |
<K> Flowable<T> |
Flowable.distinct(Function<? super T,K> keySelector,
Callable<? extends Collection<? super K>> collectionSupplier)
Returns a Flowable that emits all items emitted by the source Publisher that are distinct according
to a key selector function and based on
Object.equals(Object) comparison of the objects
returned by the key selector function. |
Flowable<T> |
Flowable.distinctUntilChanged()
Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their
immediate predecessors based on
Object.equals(Object) comparison. |
Flowable<T> |
Flowable.distinctUntilChanged(BiPredicate<? super T,? super T> comparer)
Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their
immediate predecessors when compared with each other via the provided comparator function.
|
<K> Flowable<T> |
Flowable.distinctUntilChanged(Function<? super T,K> keySelector)
Returns a Flowable that emits all items emitted by the source Publisher that are distinct from their
immediate predecessors, according to a key selector function and based on
Object.equals(Object) comparison
of those objects returned by the key selector function. |
Flowable<T> |
Flowable.doAfterNext(Consumer<? super T> onAfterNext)
Calls the specified consumer with the current item after this item has been emitted to the downstream.
|
Flowable<T> |
Flowable.doAfterTerminate(Action onAfterTerminate)
|
Flowable<T> |
Flowable.doFinally(Action onFinally)
Calls the specified action after this Flowable signals onError or onCompleted or gets canceled by
the downstream.
|
Flowable<T> |
Flowable.doOnCancel(Action onCancel)
Calls the cancel
Action if the downstream cancels the sequence. |
Flowable<T> |
Flowable.doOnComplete(Action onComplete)
Modifies the source Publisher so that it invokes an action when it calls
onComplete . |
Flowable<T> |
Flowable.doOnEach(Consumer<? super Notification<T>> onNotification)
Modifies the source Publisher so that it invokes an action for each item it emits.
|
Flowable<T> |
Flowable.doOnEach(org.reactivestreams.Subscriber<? super T> subscriber)
Modifies the source Publisher so that it notifies a Subscriber for each item and terminal event it emits.
|
Flowable<T> |
Flowable.doOnError(Consumer<? super Throwable> onError)
Modifies the source Publisher so that it invokes an action if it calls
onError . |
Flowable<T> |
Flowable.doOnLifecycle(Consumer<? super org.reactivestreams.Subscription> onSubscribe,
LongConsumer onRequest,
Action onCancel)
Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of
the sequence (subscription, cancellation, requesting).
|
Flowable<T> |
Flowable.doOnNext(Consumer<? super T> onNext)
Modifies the source Publisher so that it invokes an action when it calls
onNext . |
Flowable<T> |
Flowable.doOnRequest(LongConsumer onRequest)
Modifies the source
Publisher so that it invokes the given action when it receives a
request for more items. |
Flowable<T> |
Flowable.doOnSubscribe(Consumer<? super org.reactivestreams.Subscription> onSubscribe)
Modifies the source
Publisher so that it invokes the given action when it is subscribed from
its subscribers. |
Flowable<T> |
Flowable.doOnTerminate(Action onTerminate)
Modifies the source Publisher so that it invokes an action when it calls
onComplete or
onError . |
static <T> Flowable<T> |
Flowable.empty()
Returns a Flowable that emits no items to the
Subscriber and immediately invokes its
onComplete method. |
static <T> Flowable<T> |
Flowable.error(Callable<? extends Throwable> supplier)
Returns a Flowable that invokes a
Subscriber 's onError method when the
Subscriber subscribes to it. |
static <T> Flowable<T> |
Flowable.error(Throwable throwable)
Returns a Flowable that invokes a
Subscriber 's onError method when the
Subscriber subscribes to it. |
Flowable<T> |
Flowable.filter(Predicate<? super T> predicate)
Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Returns a Flowable that emits items based on applying a function that you supply to each item emitted
by the source Publisher, where that function returns a Publisher, and then merging those resulting
Publishers and emitting the results of this merger.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayErrors)
Returns a Flowable that emits items based on applying a function that you supply to each item emitted
by the source Publisher, where that function returns a Publisher, and then merging those resulting
Publishers and emitting the results of this merger.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency)
Returns a Flowable that emits items based on applying a function that you supply to each item emitted
by the source Publisher, where that function returns a Publisher, and then merging those resulting
Publishers and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency,
int bufferSize)
Returns a Flowable that emits items based on applying a function that you supply to each item emitted
by the source Publisher, where that function returns a Publisher, and then merging those resulting
Publishers and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> onNextMapper,
Function<? super Throwable,? extends org.reactivestreams.Publisher<? extends R>> onErrorMapper,
Callable<? extends org.reactivestreams.Publisher<? extends R>> onCompleteSupplier)
Returns a Flowable that applies a function to each item emitted or notification raised by the source
Publisher and then flattens the Publishers returned from these functions and emits the resulting items.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> onNextMapper,
Function<Throwable,? extends org.reactivestreams.Publisher<? extends R>> onErrorMapper,
Callable<? extends org.reactivestreams.Publisher<? extends R>> onCompleteSupplier,
int maxConcurrency)
Returns a Flowable that applies a function to each item emitted or notification raised by the source
Publisher and then flattens the Publishers returned from these functions and emits the resulting items,
while limiting the maximum number of concurrent subscriptions to these Publishers.
|
<R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int maxConcurrency)
Returns a Flowable that emits items based on applying a function that you supply to each item emitted
by the source Publisher, where that function returns a Publisher, and then merging those resulting
Publishers and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
<U,R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner)
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the
source Publisher and a specified collection Publisher.
|
<U,R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
boolean delayErrors)
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the
source Publisher and a specified collection Publisher.
|
<U,R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
boolean delayErrors,
int maxConcurrency)
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the
source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
<U,R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
boolean delayErrors,
int maxConcurrency,
int bufferSize)
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the
source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
<U,R> Flowable<R> |
Flowable.flatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
int maxConcurrency)
Returns a Flowable that emits the results of a specified function to the pair of values emitted by the
source Publisher and a specified collection Publisher, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
<U> Flowable<U> |
Flowable.flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns a Flowable that merges each item emitted by the source Publisher with the values in an
Iterable corresponding to that item that is generated by a selector.
|
<U,V> Flowable<V> |
Flowable.flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper,
BiFunction<? super T,? super U,? extends V> resultSelector)
Returns a Flowable that emits the results of applying a function to the pair of values from the source
Publisher and an Iterable corresponding to that item that is generated by a selector.
|
<U,V> Flowable<V> |
Flowable.flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper,
BiFunction<? super T,? super U,? extends V> resultSelector,
int prefetch)
Returns a Flowable that merges each item emitted by the source Publisher with the values in an
Iterable corresponding to that item that is generated by a selector, while limiting the number of concurrent
subscriptions to these Publishers.
|
<U> Flowable<U> |
Flowable.flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper,
int bufferSize)
Returns a Flowable that merges each item emitted by the source Publisher with the values in an
Iterable corresponding to that item that is generated by a selector.
|
<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> 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. |
<R> Flowable<R> |
Single.flatMapPublisher(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Returns a Flowable that emits items based on applying a specified function to the item emitted by the
source Single, where that function returns a Publisher.
|
<R> Flowable<R> |
Maybe.flatMapPublisher(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Returns a Flowable that emits items based on applying a specified function to the item emitted by the
source Maybe, where that function returns a Publisher.
|
<R> Flowable<R> |
Flowable.flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps each element of the upstream Flowable into SingleSources, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Flowable sequence.
|
<R> Flowable<R> |
Flowable.flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency)
Maps each element of the upstream Flowable into SingleSources, subscribes to at most
maxConcurrency SingleSources at a time and merges their onSuccess values,
in no particular order, into a single Flowable sequence, optionally delaying all errors. |
<U> Flowable<U> |
Single.flattenAsFlowable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns a Flowable that merges each item emitted by the source Single with the values in an
Iterable corresponding to that item that is generated by a selector.
|
<U> Flowable<U> |
Maybe.flattenAsFlowable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns a Flowable that merges each item emitted by the source Maybe with the values in an
Iterable corresponding to that item that is generated by a selector.
|
static <T> Flowable<T> |
Flowable.fromArray(T... items)
Converts an Array into a Publisher that emits the items in the Array.
|
static <T> Flowable<T> |
Flowable.fromCallable(Callable<? extends T> supplier)
Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then
emits the value returned from that function.
|
static <T> Flowable<T> |
Flowable.fromFuture(Future<? extends T> future)
Converts a
Future into a Publisher. |
static <T> Flowable<T> |
Flowable.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit)
Converts a
Future into a Publisher, with a timeout on the Future. |
static <T> Flowable<T> |
Flowable.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit,
Scheduler scheduler)
Converts a
Future into a Publisher, with a timeout on the Future. |
static <T> Flowable<T> |
Flowable.fromFuture(Future<? extends T> future,
Scheduler scheduler)
|
static <T> Flowable<T> |
Flowable.fromIterable(Iterable<? extends T> source)
Converts an
Iterable sequence into a Publisher that emits the items in the sequence. |
static <T> Flowable<T> |
Flowable.fromPublisher(org.reactivestreams.Publisher<? extends T> source)
Converts an arbitrary Reactive-Streams Publisher into a Flowable if not already a
Flowable.
|
static <T,S> Flowable<T> |
Flowable.generate(Callable<S> initialState,
BiConsumer<S,Emitter<T>> generator)
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
|
static <T,S> Flowable<T> |
Flowable.generate(Callable<S> initialState,
BiConsumer<S,Emitter<T>> generator,
Consumer<? super S> disposeState)
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
|
static <T,S> Flowable<T> |
Flowable.generate(Callable<S> initialState,
BiFunction<S,Emitter<T>,S> generator)
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
|
static <T,S> Flowable<T> |
Flowable.generate(Callable<S> initialState,
BiFunction<S,Emitter<T>,S> generator,
Consumer<? super S> disposeState)
Returns a cold, synchronous, stateful and backpressure-aware generator of values.
|
static <T> Flowable<T> |
Flowable.generate(Consumer<Emitter<T>> generator)
Returns a cold, synchronous, stateless and backpressure-aware generator of values.
|
<K> Flowable<GroupedFlowable<K,T>> |
Flowable.groupBy(Function<? super T,? extends K> keySelector)
Groups the items emitted by a
Publisher according to a specified criterion, and emits these
grouped items as GroupedFlowable s. |
<K> Flowable<GroupedFlowable<K,T>> |
Flowable.groupBy(Function<? super T,? extends K> keySelector,
boolean delayError)
Groups the items emitted by a
Publisher according to a specified criterion, and emits these
grouped items as GroupedFlowable s. |
<K,V> Flowable<GroupedFlowable<K,V>> |
Flowable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
Groups the items emitted by a
Publisher according to a specified criterion, and emits these
grouped items as GroupedFlowable s. |
<K,V> Flowable<GroupedFlowable<K,V>> |
Flowable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
boolean delayError)
Groups the items emitted by a
Publisher according to a specified criterion, and emits these
grouped items as GroupedFlowable s. |
<K,V> Flowable<GroupedFlowable<K,V>> |
Flowable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
boolean delayError,
int bufferSize)
Groups the items emitted by a
Publisher according to a specified criterion, and emits these
grouped items as GroupedFlowable s. |
<K,V> Flowable<GroupedFlowable<K,V>> |
Flowable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
boolean delayError,
int bufferSize,
Function<? super Consumer<Object>,? extends Map<K,Object>> evictingMapFactory)
Groups the items emitted by a
Publisher according to a specified criterion, and emits these
grouped items as GroupedFlowable s. |
<TRight,TLeftEnd,TRightEnd,R> |
Flowable.groupJoin(org.reactivestreams.Publisher<? extends TRight> other,
Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
BiFunction<? super T,? super Flowable<TRight>,? extends R> resultSelector)
Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
|
Flowable<T> |
Flowable.hide()
Hides the identity of this Flowable and its Subscription.
|
static Flowable<Long> |
Flowable.interval(long initialDelay,
long period,
TimeUnit unit)
Returns a Flowable that emits a
0L after the initialDelay and ever-increasing numbers
after each period of time thereafter. |
static Flowable<Long> |
Flowable.interval(long initialDelay,
long period,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits a
0L after the initialDelay and ever-increasing numbers
after each period of time thereafter, on a specified Scheduler . |
static Flowable<Long> |
Flowable.interval(long period,
TimeUnit unit)
Returns a Flowable that emits a sequential number every specified interval of time.
|
static Flowable<Long> |
Flowable.interval(long period,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits a sequential number every specified interval of time, on a
specified Scheduler.
|
static Flowable<Long> |
Flowable.intervalRange(long start,
long count,
long initialDelay,
long period,
TimeUnit unit)
Signals a range of long values, the first after some initial delay and the rest periodically after.
|
static Flowable<Long> |
Flowable.intervalRange(long start,
long count,
long initialDelay,
long period,
TimeUnit unit,
Scheduler scheduler)
Signals a range of long values, the first after some initial delay and the rest periodically after.
|
<TRight,TLeftEnd,TRightEnd,R> |
Flowable.join(org.reactivestreams.Publisher<? extends TRight> other,
Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
BiFunction<? super T,? super TRight,? extends R> resultSelector)
Correlates the items emitted by two Publishers based on overlapping durations.
|
static <T> Flowable<T> |
Flowable.just(T item)
Returns a Flowable that signals the given (constant reference) item and then completes.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2)
Converts two items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3)
Converts three items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4)
Converts four items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4,
T item5)
Converts five items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6)
Converts six items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7)
Converts seven items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7,
T item8)
Converts eight items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7,
T item8,
T item9)
Converts nine items into a Publisher that emits those items.
|
static <T> Flowable<T> |
Flowable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7,
T item8,
T item9,
T item10)
Converts ten items into a Publisher that emits those items.
|
<R> Flowable<R> |
Flowable.lift(FlowableOperator<? extends R,? super T> lifter)
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns a
Flowable which, when subscribed to, invokes the apply(Subscriber) method
of the provided FlowableOperator for each individual downstream Subscriber and allows the
insertion of a custom operator by accessing the downstream's Subscriber during this subscription phase
and providing a new Subscriber , containing the custom operator's intended business logic, that will be
used in the subscription process going further upstream. |
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.
|
<R> Flowable<R> |
Flowable.map(Function<? super T,? extends R> mapper)
Returns a Flowable that applies a specified function to each item emitted by the source Publisher and
emits the results of these function applications.
|
Flowable<Notification<T>> |
Flowable.materialize()
Returns a Flowable that represents all of the emissions and notifications from the source
Publisher into emissions marked with their original types within
Notification objects. |
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> Flowable<T> |
Flowable.merge(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
Flattens an Iterable of Publishers into one Publisher, without any transformation.
|
static <T> Flowable<T> |
Flowable.merge(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency)
Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the
number of concurrent subscriptions to these Publishers.
|
static <T> Flowable<T> |
Flowable.merge(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency,
int bufferSize)
Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the
number of concurrent subscriptions to these Publishers.
|
static <T> Flowable<T> |
Single.merge(Iterable<? extends SingleSource<? extends T>> sources)
Merges an Iterable sequence of SingleSource instances into a single Flowable sequence,
running all SingleSources at once.
|
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,
MaybeSource<? extends T> source4)
Flattens four MaybeSources into a single Flowable, 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> |
Flowable.merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by
those Publishers, without any transformation.
|
static <T> Flowable<T> |
Flowable.merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency)
Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by
those Publishers, without any transformation, while limiting the maximum number of concurrent
subscriptions to these Publishers.
|
static <T> Flowable<T> |
Single.merge(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.
|
static <T> Flowable<T> |
Flowable.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Flattens two Publishers into a single Publisher, without any transformation.
|
static <T> Flowable<T> |
Flowable.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3)
Flattens three Publishers into a single Publisher, without any transformation.
|
static <T> Flowable<T> |
Flowable.merge(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4)
Flattens four Publishers into a single Publisher, without any transformation.
|
static <T> Flowable<T> |
Single.merge(SingleSource<? extends T> source1,
SingleSource<? extends T> source2)
Flattens two Singles into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Single.merge(SingleSource<? extends T> source1,
SingleSource<? extends T> source2,
SingleSource<? extends T> source3)
Flattens three Singles into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Single.merge(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.
|
static <T> Flowable<T> |
Flowable.mergeArray(int maxConcurrency,
int bufferSize,
org.reactivestreams.Publisher<? extends T>... sources)
Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the
number of concurrent subscriptions to these Publishers.
|
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> |
Flowable.mergeArray(org.reactivestreams.Publisher<? extends T>... sources)
Flattens an Array of Publishers into one Publisher, without any transformation.
|
static <T> Flowable<T> |
Flowable.mergeArrayDelayError(int maxConcurrency,
int bufferSize,
org.reactivestreams.Publisher<? extends T>... sources)
Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source Publishers without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
|
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> |
Flowable.mergeArrayDelayError(org.reactivestreams.Publisher<? extends T>... sources)
Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source Publishers without being interrupted by an error
notification from one of them.
|
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> |
Flowable.mergeDelayError(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources)
Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source Publishers without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Flowable.mergeDelayError(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency)
Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source Publishers without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
|
static <T> Flowable<T> |
Flowable.mergeDelayError(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency,
int bufferSize)
Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source Publishers without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.
|
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(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,
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(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.
|
static <T> Flowable<T> |
Flowable.mergeDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to
receive all successfully emitted items from all of the source Publishers without being interrupted by
an error notification from one of them.
|
static <T> Flowable<T> |
Flowable.mergeDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int maxConcurrency)
Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to
receive all successfully emitted items from all of the source Publishers without being interrupted by
an error notification from one of them, while limiting the
number of concurrent subscriptions to these Publishers.
|
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> |
Flowable.mergeDelayError(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from each of the source Publishers without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Flowable.mergeDelayError(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3)
Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source Publishers without being interrupted by an error
notification from one of them.
|
static <T> Flowable<T> |
Flowable.mergeDelayError(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
org.reactivestreams.Publisher<? extends T> source3,
org.reactivestreams.Publisher<? extends T> source4)
Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all
successfully emitted items from all of the source Publishers without being interrupted by an error
notification from one of them.
|
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.
|
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.
|
Flowable<T> |
Flowable.mergeWith(org.reactivestreams.Publisher<? extends T> other)
Flattens this and another Publisher into a single Publisher, without any transformation.
|
Flowable<T> |
Single.mergeWith(SingleSource<? extends T> other)
Flattens this and another Single into a single Flowable, without any transformation.
|
Flowable<T> |
Flowable.mergeWith(SingleSource<? extends T> other)
Merges the sequence of items of this Flowable with the success value of the other SingleSource.
|
static <T> Flowable<T> |
Flowable.never()
Returns a Flowable that never sends any items or notifications to a
Subscriber . |
Flowable<T> |
Flowable.observeOn(Scheduler scheduler)
Modifies a Publisher to perform its emissions and notifications on a specified
Scheduler ,
asynchronously with a bounded buffer of bufferSize() slots. |
Flowable<T> |
Flowable.observeOn(Scheduler scheduler,
boolean delayError)
Modifies a Publisher to perform its emissions and notifications on a specified
Scheduler ,
asynchronously with a bounded buffer and optionally delays onError notifications. |
Flowable<T> |
Flowable.observeOn(Scheduler scheduler,
boolean delayError,
int bufferSize)
Modifies a Publisher to perform its emissions and notifications on a specified
Scheduler ,
asynchronously with a bounded buffer of configurable size and optionally delays onError notifications. |
<U> Flowable<U> |
Flowable.ofType(Class<U> clazz)
Filters the items emitted by a Publisher, only emitting those of the specified type.
|
Flowable<T> |
Flowable.onBackpressureBuffer()
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer these
items indefinitely until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(boolean delayError)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer these
items indefinitely until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(int capacity)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to
a given amount of items until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(int capacity,
Action onOverflow)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to
a given amount of items until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(int capacity,
boolean delayError)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to
a given amount of items until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(int capacity,
boolean delayError,
boolean unbounded)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to
a given amount of items until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(int capacity,
boolean delayError,
boolean unbounded,
Action onOverflow)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to
a given amount of items until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureBuffer(long capacity,
Action onOverflow,
BackpressureOverflowStrategy overflowStrategy)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to buffer up to
a given amount of items until they can be emitted.
|
Flowable<T> |
Flowable.onBackpressureDrop()
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard,
rather than emit, those items that its Subscriber is not prepared to observe.
|
Flowable<T> |
Flowable.onBackpressureDrop(Consumer<? super T> onDrop)
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to discard,
rather than emit, those items that its Subscriber is not prepared to observe.
|
Flowable<T> |
Flowable.onBackpressureLatest()
Instructs a Publisher that is emitting items faster than its Subscriber can consume them to
hold onto the latest value and emit that on request.
|
Flowable<T> |
Flowable.onErrorResumeNext(Function<? super Throwable,? extends org.reactivestreams.Publisher<? extends T>> resumeFunction)
Instructs a Publisher to pass control to another Publisher rather than invoking
onError if it encounters an error. |
Flowable<T> |
Flowable.onErrorResumeNext(org.reactivestreams.Publisher<? extends T> next)
Instructs a Publisher to pass control to another Publisher rather than invoking
onError if it encounters an error. |
Flowable<T> |
Flowable.onErrorReturn(Function<? super Throwable,? extends T> valueSupplier)
Instructs a Publisher to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Flowable<T> |
Flowable.onErrorReturnItem(T item)
Instructs a Publisher to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Flowable<T> |
Flowable.onExceptionResumeNext(org.reactivestreams.Publisher<? extends T> next)
Instructs a Publisher to pass control to another Publisher rather than invoking
onError if it encounters an Exception . |
Flowable<T> |
Flowable.onTerminateDetach()
Nulls out references to the upstream producer and downstream Subscriber if
the sequence is terminated or downstream cancels.
|
<R> Flowable<R> |
Flowable.publish(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>> selector,
int prefetch)
Returns a Flowable that emits the results of invoking a specified selector on items emitted by a
ConnectableFlowable that shares a single subscription to the underlying sequence. |
<R> Flowable<R> |
Flowable.publish(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector)
Returns a Flowable that emits the results of invoking a specified selector on items emitted by a
ConnectableFlowable that shares a single subscription to the underlying sequence. |
static Flowable<Integer> |
Flowable.range(int start,
int count)
Returns a Flowable that emits a sequence of Integers within a specified range.
|
static Flowable<Long> |
Flowable.rangeLong(long start,
long count)
Returns a Flowable that emits a sequence of Longs within a specified range.
|
Flowable<T> |
Flowable.rebatchRequests(int n)
Requests
n initially from the upstream and then 75% of n subsequently
after 75% of n values have been emitted to the downstream. |
Flowable<T> |
Single.repeat()
Repeatedly re-subscribes to the current Single and emits each success value.
|
Flowable<T> |
Maybe.repeat()
Returns a Flowable that repeats the sequence of items emitted by the source Maybe indefinitely.
|
Flowable<T> |
Flowable.repeat()
Returns a Flowable that repeats the sequence of items emitted by the source Publisher indefinitely.
|
Flowable<T> |
Single.repeat(long times)
Re-subscribes to the current Single at most the given number of times and emits each success value.
|
Flowable<T> |
Maybe.repeat(long times)
Returns a Flowable that repeats the sequence of items emitted by the source Maybe at most
count times. |
Flowable<T> |
Flowable.repeat(long times)
Returns a Flowable that repeats the sequence of items emitted by the source Publisher at most
count times. |
Flowable<T> |
Single.repeatUntil(BooleanSupplier stop)
Re-subscribes to the current Single until the given BooleanSupplier returns true.
|
Flowable<T> |
Maybe.repeatUntil(BooleanSupplier stop)
Returns a Flowable that repeats the sequence of items emitted by the source Maybe until
the provided stop function returns true.
|
Flowable<T> |
Flowable.repeatUntil(BooleanSupplier stop)
Returns a Flowable that repeats the sequence of items emitted by the source Publisher until
the provided stop function returns true.
|
Flowable<T> |
Single.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Re-subscribes to the current Single if
the Publisher returned by the handler function signals a value in response to a
value signalled through the Flowable the handle receives.
|
Flowable<T> |
Maybe.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Flowable that emits the same values as the source Publisher with the exception of an
onComplete . |
Flowable<T> |
Flowable.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Flowable that emits the same values as the source Publisher with the exception of an
onComplete . |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector)
Returns a Flowable that emits items that are the results of invoking a specified selector on the items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying bufferSize notifications. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize,
long time,
TimeUnit unit)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying no more than bufferSize items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying no more than bufferSize items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying a maximum of bufferSize items. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
long time,
TimeUnit unit)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying all items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying all items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher. |
Flowable<T> |
Flowable.retry()
Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls
onError
(infinite retry count). |
Flowable<T> |
Flowable.retry(BiPredicate<? super Integer,? super Throwable> predicate)
Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls
onError
and the predicate returns true for that specific exception and retry count. |
Flowable<T> |
Flowable.retry(long count)
Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls
onError
up to a specified number of retries. |
Flowable<T> |
Flowable.retry(long times,
Predicate<? super Throwable> predicate)
Retries at most times or until the predicate returns false, whichever happens first.
|
Flowable<T> |
Flowable.retry(Predicate<? super Throwable> predicate)
Retries the current Flowable if the predicate returns true.
|
Flowable<T> |
Flowable.retryUntil(BooleanSupplier stop)
Retries until the given stop function returns true.
|
Flowable<T> |
Flowable.retryWhen(Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Flowable that emits the same values as the source Publisher with the exception of an
onError . |
Flowable<T> |
Flowable.sample(long period,
TimeUnit unit)
Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher
within periodic time intervals.
|
Flowable<T> |
Flowable.sample(long period,
TimeUnit unit,
boolean emitLast)
Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher
within periodic time intervals and optionally emit the very last upstream item when the upstream completes.
|
Flowable<T> |
Flowable.sample(long period,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher
within periodic time intervals, where the intervals are defined on a particular Scheduler.
|
Flowable<T> |
Flowable.sample(long period,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast)
Returns a Flowable that emits the most recently emitted item (if any) emitted by the source Publisher
within periodic time intervals, where the intervals are defined on a particular Scheduler
and optionally emit the very last upstream item when the upstream completes.
|
<U> Flowable<T> |
Flowable.sample(org.reactivestreams.Publisher<U> sampler)
Returns a Flowable that, when the specified
sampler Publisher emits an item or completes,
emits the most recently emitted item (if any) emitted by the source Publisher since the previous
emission from the sampler Publisher. |
<U> Flowable<T> |
Flowable.sample(org.reactivestreams.Publisher<U> sampler,
boolean emitLast)
Returns a Flowable that, when the specified
sampler Publisher emits an item or completes,
emits the most recently emitted item (if any) emitted by the source Publisher since the previous
emission from the sampler Publisher
and optionally emit the very last upstream item when the upstream or other Publisher complete. |
Flowable<T> |
Flowable.scan(BiFunction<T,T,T> accumulator)
Returns a Flowable that applies a specified accumulator function to the first item emitted by a source
Publisher, then feeds the result of that function along with the second item emitted by the source
Publisher into the same function, and so on until all items have been emitted by the source Publisher,
emitting the result of each of these iterations.
|
<R> Flowable<R> |
Flowable.scan(R initialValue,
BiFunction<R,? super T,R> accumulator)
Returns a Flowable that applies a specified accumulator function to the first item emitted by a source
Publisher and a seed value, then feeds the result of that function along with the second item emitted by
the source Publisher into the same function, and so on until all items have been emitted by the source
Publisher, emitting the result of each of these iterations.
|
<R> Flowable<R> |
Flowable.scanWith(Callable<R> seedSupplier,
BiFunction<R,? super T,R> accumulator)
Returns a Flowable that applies a specified accumulator function to the first item emitted by a source
Publisher and a seed value, then feeds the result of that function along with the second item emitted by
the source Publisher into the same function, and so on until all items have been emitted by the source
Publisher, emitting the result of each of these iterations.
|
Flowable<T> |
Flowable.serialize()
Forces a Publisher's emissions and notifications to be serialized and for it to obey
the Publisher contract in other ways.
|
Flowable<T> |
Flowable.share()
Returns a new
Publisher that multicasts (and shares a single subscription to) the original Publisher . |
Flowable<T> |
Flowable.skip(long count)
Returns a Flowable that skips the first
count items emitted by the source Publisher and emits
the remainder. |
Flowable<T> |
Flowable.skip(long time,
TimeUnit unit)
Returns a Flowable that skips values emitted by the source Publisher before a specified time window
elapses.
|
Flowable<T> |
Flowable.skip(long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that skips values emitted by the source Publisher before a specified time window
on a specified
Scheduler elapses. |
Flowable<T> |
Flowable.skipLast(int count)
Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the
source Publisher.
|
Flowable<T> |
Flowable.skipLast(long time,
TimeUnit unit)
Returns a Flowable that drops items emitted by the source Publisher during a specified time window
before the source completes.
|
Flowable<T> |
Flowable.skipLast(long time,
TimeUnit unit,
boolean delayError)
Returns a Flowable that drops items emitted by the source Publisher during a specified time window
before the source completes.
|
Flowable<T> |
Flowable.skipLast(long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that drops items emitted by the source Publisher during a specified time window
(defined on a specified scheduler) before the source completes.
|
Flowable<T> |
Flowable.skipLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns a Flowable that drops items emitted by the source Publisher during a specified time window
(defined on a specified scheduler) before the source completes.
|
Flowable<T> |
Flowable.skipLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError,
int bufferSize)
Returns a Flowable that drops items emitted by the source Publisher during a specified time window
(defined on a specified scheduler) before the source completes.
|
<U> Flowable<T> |
Flowable.skipUntil(org.reactivestreams.Publisher<U> other)
Returns a Flowable that skips items emitted by the source Publisher until a second Publisher emits
an item.
|
Flowable<T> |
Flowable.skipWhile(Predicate<? super T> predicate)
Returns a Flowable that skips all items emitted by the source Publisher as long as a specified
condition holds true, but emits all further source items as soon as the condition becomes false.
|
Flowable<T> |
Flowable.sorted()
Returns a Flowable that emits the events emitted by source Publisher, in a
sorted order.
|
Flowable<T> |
Flowable.sorted(Comparator<? super T> sortFunction)
Returns a Flowable that emits the events emitted by source Publisher, in a
sorted order based on a specified comparison function.
|
Flowable<T> |
Flowable.startWith(Iterable<? extends T> items)
Returns a Flowable that emits the items in a specified
Iterable before it begins to emit items
emitted by the source Publisher. |
Flowable<T> |
Flowable.startWith(org.reactivestreams.Publisher<? extends T> other)
Returns a Flowable that emits the items in a specified
Publisher before it begins to emit
items emitted by the source Publisher. |
<T> Flowable<T> |
Completable.startWith(org.reactivestreams.Publisher<T> other)
Returns a Flowable which first delivers the events
of the other Publisher then runs this Completable.
|
Flowable<T> |
Flowable.startWith(T value)
Returns a Flowable that emits a specified item before it begins to emit items emitted by the source
Publisher.
|
Flowable<T> |
Flowable.startWithArray(T... items)
Returns a Flowable that emits the specified items before it begins to emit items emitted by the source
Publisher.
|
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler)
Asynchronously subscribes Subscribers to this Publisher on the specified
Scheduler . |
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler,
boolean requestOn)
|
Flowable<T> |
Flowable.switchIfEmpty(org.reactivestreams.Publisher<? extends T> other)
Returns a Flowable that emits the items emitted by the source Publisher or the items of an alternate
Publisher if the source Publisher is empty.
|
<R> Flowable<R> |
Flowable.switchMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Returns a new Publisher by applying a function that you supply to each item emitted by the source
Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted
of these Publishers.
|
<R> Flowable<R> |
Flowable.switchMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int bufferSize)
Returns a new Publisher by applying a function that you supply to each item emitted by the source
Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted
of these Publishers.
|
<R> Flowable<R> |
Flowable.switchMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
Returns a new Publisher by applying a function that you supply to each item emitted by the source
Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted
of these Publishers and delays any error until all Publishers terminate.
|
<R> Flowable<R> |
Flowable.switchMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int bufferSize)
Returns a new Publisher by applying a function that you supply to each item emitted by the source
Publisher that returns a Publisher, and then emitting the items emitted by the most recently emitted
of these Publishers and delays any error until all Publishers 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> 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> 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> 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. |
static <T> Flowable<T> |
Flowable.switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the
most recently emitted of those Publishers.
|
static <T> Flowable<T> |
Flowable.switchOnNext(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int bufferSize)
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the
most recently emitted of those Publishers.
|
static <T> Flowable<T> |
Flowable.switchOnNextDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources)
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the
most recently emitted of those Publishers and delays any exception until all Publishers terminate.
|
static <T> Flowable<T> |
Flowable.switchOnNextDelayError(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
int prefetch)
Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the
most recently emitted of those Publishers and delays any exception until all Publishers terminate.
|
Flowable<T> |
Flowable.take(long count)
Returns a Flowable that emits only the first
count items emitted by the source Publisher. |
Flowable<T> |
Flowable.take(long time,
TimeUnit unit)
Returns a Flowable that emits those items emitted by source Publisher before a specified time runs
out.
|
Flowable<T> |
Flowable.take(long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a
specified Scheduler) runs out.
|
Flowable<T> |
Flowable.takeLast(int count)
Returns a Flowable that emits at most the last
count items emitted by the source Publisher. |
Flowable<T> |
Flowable.takeLast(long count,
long time,
TimeUnit unit)
Returns a Flowable that emits at most a specified number of items from the source Publisher that were
emitted in a specified window of time before the Publisher completed.
|
Flowable<T> |
Flowable.takeLast(long count,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits at most a specified number of items from the source Publisher that were
emitted in a specified window of time before the Publisher completed, where the timing information is
provided by a given Scheduler.
|
Flowable<T> |
Flowable.takeLast(long count,
long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError,
int bufferSize)
Returns a Flowable that emits at most a specified number of items from the source Publisher that were
emitted in a specified window of time before the Publisher completed, where the timing information is
provided by a given Scheduler.
|
Flowable<T> |
Flowable.takeLast(long time,
TimeUnit unit)
Returns a Flowable that emits the items from the source Publisher that were emitted in a specified
window of time before the Publisher completed.
|
Flowable<T> |
Flowable.takeLast(long time,
TimeUnit unit,
boolean delayError)
Returns a Flowable that emits the items from the source Publisher that were emitted in a specified
window of time before the Publisher completed.
|
Flowable<T> |
Flowable.takeLast(long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits the items from the source Publisher that were emitted in a specified
window of time before the Publisher completed, where the timing information is provided by a specified
Scheduler.
|
Flowable<T> |
Flowable.takeLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns a Flowable that emits the items from the source Publisher that were emitted in a specified
window of time before the Publisher completed, where the timing information is provided by a specified
Scheduler.
|
Flowable<T> |
Flowable.takeLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError,
int bufferSize)
Returns a Flowable that emits the items from the source Publisher that were emitted in a specified
window of time before the Publisher completed, where the timing information is provided by a specified
Scheduler.
|
Flowable<T> |
Flowable.takeUntil(Predicate<? super T> stopPredicate)
Returns a Flowable that emits items emitted by the source Publisher, checks the specified predicate
for each item, and then completes when the condition is satisfied.
|
<U> Flowable<T> |
Flowable.takeUntil(org.reactivestreams.Publisher<U> other)
Returns a Flowable that emits the items emitted by the source Publisher until a second Publisher
emits an item.
|
Flowable<T> |
Flowable.takeWhile(Predicate<? super T> predicate)
Returns a Flowable that emits items emitted by the source Publisher so long as each item satisfied a
specified condition, and then completes as soon as this condition is not satisfied.
|
Flowable<T> |
Flowable.throttleFirst(long windowDuration,
TimeUnit unit)
Returns a Flowable that emits only the first item emitted by the source Publisher during sequential
time windows of a specified duration.
|
Flowable<T> |
Flowable.throttleFirst(long skipDuration,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits only the first item emitted by the source Publisher during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler.
|
Flowable<T> |
Flowable.throttleLast(long intervalDuration,
TimeUnit unit)
Returns a Flowable that emits only the last item emitted by the source Publisher during sequential
time windows of a specified duration.
|
Flowable<T> |
Flowable.throttleLast(long intervalDuration,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits only the last item emitted by the source Publisher during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler.
|
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. |
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. |
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. |
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. |
Flowable<T> |
Flowable.throttleWithTimeout(long timeout,
TimeUnit unit)
Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the
source Publisher that are followed by newer items before a timeout value expires.
|
Flowable<T> |
Flowable.throttleWithTimeout(long timeout,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that mirrors the source Publisher, except that it drops items emitted by the
source Publisher that are followed by newer items before a timeout value expires on a specified
Scheduler.
|
Flowable<Timed<T>> |
Flowable.timeInterval()
Returns a Flowable that emits records of the time interval between consecutive items emitted by the
source Publisher.
|
Flowable<Timed<T>> |
Flowable.timeInterval(Scheduler scheduler)
Returns a Flowable that emits records of the time interval between consecutive items emitted by the
source Publisher, where this interval is computed on a specified Scheduler.
|
Flowable<Timed<T>> |
Flowable.timeInterval(TimeUnit unit)
Returns a Flowable that emits records of the time interval between consecutive items emitted by the
source Publisher.
|
Flowable<Timed<T>> |
Flowable.timeInterval(TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits records of the time interval between consecutive items emitted by the
source Publisher, where this interval is computed on a specified Scheduler.
|
<V> Flowable<T> |
Flowable.timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator)
Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a
TimeoutException if an item emitted by the source Publisher doesn't arrive within a window of
time after the emission of the previous item, where that period of time is measured by a Publisher that
is a function of the previous item. |
<V> Flowable<T> |
Flowable.timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator,
Flowable<? extends T> other)
Returns a Flowable that mirrors the source Publisher, but that switches to a fallback Publisher if
an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the
previous item, where that period of time is measured by a Publisher that is a function of the previous
item.
|
Flowable<T> |
Flowable.timeout(long timeout,
TimeUnit timeUnit)
Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted
item.
|
Flowable<T> |
Flowable.timeout(long timeout,
TimeUnit timeUnit,
org.reactivestreams.Publisher<? extends T> other)
Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted
item.
|
Flowable<T> |
Flowable.timeout(long timeout,
TimeUnit timeUnit,
Scheduler scheduler)
Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted
item, where this policy is governed by a specified Scheduler.
|
Flowable<T> |
Flowable.timeout(long timeout,
TimeUnit timeUnit,
Scheduler scheduler,
org.reactivestreams.Publisher<? extends T> other)
Returns a Flowable that mirrors the source Publisher but applies a timeout policy for each emitted
item using a specified Scheduler.
|
<U,V> Flowable<T> |
Flowable.timeout(org.reactivestreams.Publisher<U> firstTimeoutIndicator,
Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator)
Returns a Flowable that mirrors the source Publisher, but notifies Subscribers of a
TimeoutException if either the first item emitted by the source Publisher or any subsequent item
doesn't arrive within time windows defined by other Publishers. |
<U,V> Flowable<T> |
Flowable.timeout(org.reactivestreams.Publisher<U> firstTimeoutIndicator,
Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator,
org.reactivestreams.Publisher<? extends T> other)
Returns a Flowable that mirrors the source Publisher, but switches to a fallback Publisher if either
the first item emitted by the source Publisher or any subsequent item doesn't arrive within time windows
defined by other Publishers.
|
static Flowable<Long> |
Flowable.timer(long delay,
TimeUnit unit)
Returns a Flowable that emits
0L after a specified delay, and then completes. |
static Flowable<Long> |
Flowable.timer(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits
0L after a specified delay, on a specified Scheduler, and then
completes. |
Flowable<Timed<T>> |
Flowable.timestamp()
Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a
Timed object. |
Flowable<Timed<T>> |
Flowable.timestamp(Scheduler scheduler)
Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a
Timed object whose timestamps are provided by a specified Scheduler. |
Flowable<Timed<T>> |
Flowable.timestamp(TimeUnit unit)
Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a
Timed object. |
Flowable<Timed<T>> |
Flowable.timestamp(TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits each item emitted by the source Publisher, wrapped in a
Timed object whose timestamps are provided by a specified Scheduler. |
Flowable<T> |
Single.toFlowable()
Converts this Single into a
Flowable . |
Flowable<T> |
Maybe.toFlowable()
Converts this Maybe into a backpressure-aware Flowable instance composing cancellation
through.
|
<T> Flowable<T> |
Completable.toFlowable()
Returns a Flowable which when subscribed to subscribes to this Completable and
relays the terminal events to the subscriber.
|
Flowable<T> |
Observable.toFlowable(BackpressureStrategy strategy)
Converts the current Observable into a Flowable by applying the specified backpressure strategy.
|
static <T> Flowable<T> |
Flowable.unsafeCreate(org.reactivestreams.Publisher<T> onSubscribe)
Create a Flowable by wrapping a Publisher which has to be implemented according
to the Reactive-Streams specification by handling backpressure and
cancellation correctly; no safeguards are provided by the Flowable itself.
|
Flowable<T> |
Flowable.unsubscribeOn(Scheduler scheduler)
Modifies the source Publisher so that subscribers will cancel it on a specified
Scheduler . |
static <T,D> Flowable<T> |
Flowable.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier,
Consumer<? super D> resourceDisposer)
Constructs a Publisher that creates a dependent resource object which is disposed of on cancellation.
|
static <T,D> Flowable<T> |
Flowable.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier,
Consumer<? super D> resourceDisposer,
boolean eager)
Constructs a Publisher that creates a dependent resource object which is disposed of just before
termination if you have set
disposeEagerly to true and cancellation does not occur
before termination. |
<B> Flowable<Flowable<T>> |
Flowable.window(Callable<? extends org.reactivestreams.Publisher<B>> boundaryIndicatorSupplier)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<B> Flowable<Flowable<T>> |
Flowable.window(Callable<? extends org.reactivestreams.Publisher<B>> boundaryIndicatorSupplier,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long count)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long count,
long skip)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long count,
long skip,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
TimeUnit unit)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
long count)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
long count,
boolean restart)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count,
boolean restart)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count,
boolean restart,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<B> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<B> boundaryIndicator)
Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher
where the boundary of each window is determined by the items emitted from a specified boundary-governing
Publisher.
|
<B> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<B> boundaryIndicator,
int bufferSize)
Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher
where the boundary of each window is determined by the items emitted from a specified boundary-governing
Publisher.
|
<U,V> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<U> openingIndicator,
Function<? super U,? extends org.reactivestreams.Publisher<V>> closingIndicator)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<U,V> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<U> openingIndicator,
Function<? super U,? extends org.reactivestreams.Publisher<V>> closingIndicator,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<R> Flowable<R> |
Flowable.withLatestFrom(Iterable<? extends org.reactivestreams.Publisher<?>> others,
Function<? super Object[],R> combiner)
Combines the value emission from this Publisher with the latest emissions from the
other Publishers via a function to produce the output item.
|
<R> Flowable<R> |
Flowable.withLatestFrom(org.reactivestreams.Publisher<?>[] others,
Function<? super Object[],R> combiner)
Combines the value emission from this Publisher with the latest emissions from the
other Publishers via a function to produce the output item.
|
<U,R> Flowable<R> |
Flowable.withLatestFrom(org.reactivestreams.Publisher<? extends U> other,
BiFunction<? super T,? super U,? extends R> combiner)
Merges the specified Publisher into this Publisher sequence by using the
resultSelector
function only when the source Publisher (this instance) emits an item. |
<T1,T2,R> Flowable<R> |
Flowable.withLatestFrom(org.reactivestreams.Publisher<T1> source1,
org.reactivestreams.Publisher<T2> source2,
Function3<? super T,? super T1,? super T2,R> combiner)
Combines the value emission from this Publisher with the latest emissions from the
other Publishers via a function to produce the output item.
|
<T1,T2,T3,R> |
Flowable.withLatestFrom(org.reactivestreams.Publisher<T1> source1,
org.reactivestreams.Publisher<T2> source2,
org.reactivestreams.Publisher<T3> source3,
Function4<? super T,? super T1,? super T2,? super T3,R> combiner)
Combines the value emission from this Publisher with the latest emissions from the
other Publishers via a function to produce the output item.
|
<T1,T2,T3,T4,R> |
Flowable.withLatestFrom(org.reactivestreams.Publisher<T1> source1,
org.reactivestreams.Publisher<T2> source2,
org.reactivestreams.Publisher<T3> source3,
org.reactivestreams.Publisher<T4> source4,
Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner)
Combines the value emission from this Publisher with the latest emissions from the
other Publishers via a function to produce the output item.
|
static <T,R> Flowable<R> |
Flowable.zip(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other Publishers.
|
static <T,R> Flowable<R> |
Flowable.zip(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
n items emitted, in sequence, by the n Publishers emitted by a specified Publisher.
|
static <T1,T2,R> Flowable<R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other Publishers.
|
static <T1,T2,R> Flowable<R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper,
boolean delayError)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other Publishers.
|
static <T1,T2,R> Flowable<R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper,
boolean delayError,
int bufferSize)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other Publishers.
|
static <T1,T2,T3,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
three items emitted, in sequence, by three other Publishers.
|
static <T1,T2,T3,T4,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
four items emitted, in sequence, by four other Publishers.
|
static <T1,T2,T3,T4,T5,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
five items emitted, in sequence, by five other Publishers.
|
static <T1,T2,T3,T4,T5,T6,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
six items emitted, in sequence, by six other Publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
seven items emitted, in sequence, by seven other Publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
org.reactivestreams.Publisher<? 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 Flowable that emits the results of a specified combiner function applied to combinations of
eight items emitted, in sequence, by eight other Publishers.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Flowable.zip(org.reactivestreams.Publisher<? extends T1> source1,
org.reactivestreams.Publisher<? extends T2> source2,
org.reactivestreams.Publisher<? extends T3> source3,
org.reactivestreams.Publisher<? extends T4> source4,
org.reactivestreams.Publisher<? extends T5> source5,
org.reactivestreams.Publisher<? extends T6> source6,
org.reactivestreams.Publisher<? extends T7> source7,
org.reactivestreams.Publisher<? extends T8> source8,
org.reactivestreams.Publisher<? 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 Flowable that emits the results of a specified combiner function applied to combinations of
nine items emitted, in sequence, by nine other Publishers.
|
static <T,R> Flowable<R> |
Flowable.zipArray(Function<? super Object[],? extends R> zipper,
boolean delayError,
int bufferSize,
org.reactivestreams.Publisher<? extends T>... sources)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an array of other Publishers.
|
static <T,R> Flowable<R> |
Flowable.zipIterable(Iterable<? extends org.reactivestreams.Publisher<? extends T>> sources,
Function<? super Object[],? extends R> zipper,
boolean delayError,
int bufferSize)
Returns a Flowable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other Publishers.
|
<U,R> Flowable<R> |
Flowable.zipWith(Iterable<U> other,
BiFunction<? super T,? super U,? extends R> zipper)
Returns a Flowable that emits items that are the result of applying a specified function to pairs of
values, one each from the source Publisher and a specified Iterable sequence.
|
<U,R> Flowable<R> |
Flowable.zipWith(org.reactivestreams.Publisher<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper)
Returns a Flowable that emits items that are the result of applying a specified function to pairs of
values, one each from the source Publisher and another specified Publisher.
|
<U,R> Flowable<R> |
Flowable.zipWith(org.reactivestreams.Publisher<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper,
boolean delayError)
Returns a Flowable that emits items that are the result of applying a specified function to pairs of
values, one each from the source Publisher and another specified Publisher.
|
<U,R> Flowable<R> |
Flowable.zipWith(org.reactivestreams.Publisher<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper,
boolean delayError,
int bufferSize)
Returns a Flowable that emits items that are the result of applying a specified function to pairs of
values, one each from the source Publisher and another specified Publisher.
|
Modifier and Type | Method and Description |
---|---|
<B> Flowable<Flowable<T>> |
Flowable.window(Callable<? extends org.reactivestreams.Publisher<B>> boundaryIndicatorSupplier)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<B> Flowable<Flowable<T>> |
Flowable.window(Callable<? extends org.reactivestreams.Publisher<B>> boundaryIndicatorSupplier,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long count)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long count,
long skip)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long count,
long skip,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
TimeUnit unit)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
long count)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
long count,
boolean restart)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count,
boolean restart)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count,
boolean restart,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<B> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<B> boundaryIndicator)
Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher
where the boundary of each window is determined by the items emitted from a specified boundary-governing
Publisher.
|
<B> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<B> boundaryIndicator,
int bufferSize)
Returns a Flowable that emits non-overlapping windows of items it collects from the source Publisher
where the boundary of each window is determined by the items emitted from a specified boundary-governing
Publisher.
|
<U,V> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<U> openingIndicator,
Function<? super U,? extends org.reactivestreams.Publisher<V>> closingIndicator)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
<U,V> Flowable<Flowable<T>> |
Flowable.window(org.reactivestreams.Publisher<U> openingIndicator,
Function<? super U,? extends org.reactivestreams.Publisher<V>> closingIndicator,
int bufferSize)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Modifier and Type | Method and Description |
---|---|
R |
FlowableConverter.apply(Flowable<T> upstream)
Applies a function to the upstream Flowable and returns a converted value of type
R . |
org.reactivestreams.Publisher<Downstream> |
FlowableTransformer.apply(Flowable<Upstream> upstream)
Applies a function to the upstream Flowable and returns a Publisher with
optionally different element type.
|
<TOpening,TClosing> |
Flowable.buffer(Flowable<? extends TOpening> openingIndicator,
Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> closingIndicator)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<TOpening,TClosing,U extends Collection<? super T>> |
Flowable.buffer(Flowable<? extends TOpening> openingIndicator,
Function<? super TOpening,? extends org.reactivestreams.Publisher<? extends TClosing>> closingIndicator,
Callable<U> bufferSupplier)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
<V> Flowable<T> |
Flowable.timeout(Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator,
Flowable<? extends T> other)
Returns a Flowable that mirrors the source Publisher, but that switches to a fallback Publisher if
an item emitted by the source Publisher doesn't arrive within a window of time after the emission of the
previous item, where that period of time is measured by a Publisher that is a function of the previous
item.
|
Modifier and Type | Method and Description |
---|---|
<TRight,TLeftEnd,TRightEnd,R> |
Flowable.groupJoin(org.reactivestreams.Publisher<? extends TRight> other,
Function<? super T,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
BiFunction<? super T,? super Flowable<TRight>,? extends R> resultSelector)
Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.
|
<R> Flowable<R> |
Flowable.publish(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>> selector,
int prefetch)
Returns a Flowable that emits the results of invoking a specified selector on items emitted by a
ConnectableFlowable that shares a single subscription to the underlying sequence. |
<R> Flowable<R> |
Flowable.publish(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector)
Returns a Flowable that emits the results of invoking a specified selector on items emitted by a
ConnectableFlowable that shares a single subscription to the underlying sequence. |
Flowable<T> |
Single.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Re-subscribes to the current Single if
the Publisher returned by the handler function signals a value in response to a
value signalled through the Flowable the handle receives.
|
Flowable<T> |
Maybe.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Flowable that emits the same values as the source Publisher with the exception of an
onComplete . |
Flowable<T> |
Flowable.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Flowable that emits the same values as the source Publisher with the exception of an
onComplete . |
Completable |
Completable.repeatWhen(Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Completable instance that repeats when the Publisher returned by the handler
emits an item or completes when this Publisher emits a completed event.
|
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector)
Returns a Flowable that emits items that are the results of invoking a specified selector on the items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying bufferSize notifications. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize,
long time,
TimeUnit unit)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying no more than bufferSize items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying no more than bufferSize items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
int bufferSize,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying a maximum of bufferSize items. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
long time,
TimeUnit unit)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying all items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher,
replaying all items that were emitted within a specified time window. |
<R> Flowable<R> |
Flowable.replay(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
Scheduler scheduler)
Returns a Flowable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableFlowable that shares a single subscription to the source Publisher. |
Single<T> |
Single.retryWhen(Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
Re-subscribes to the current Single if and when the Publisher returned by the handler
function signals a value.
|
Maybe<T> |
Maybe.retryWhen(Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Maybe that emits the same values as the source Maybe with the exception of an
onError . |
Flowable<T> |
Flowable.retryWhen(Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Flowable that emits the same values as the source Publisher with the exception of an
onError . |
Completable |
Completable.retryWhen(Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler)
Returns a Completable which given a Publisher and when this Completable emits an error, delivers
that error through a Flowable and the Publisher should signal a value indicating a retry in response
or a terminal event indicating a termination.
|
<R> R |
Flowable.to(Function<? super Flowable<T>,R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<S extends Scheduler & Disposable> |
Scheduler.when(Function<Flowable<Flowable<Completable>>,Completable> combine)
Allows the use of operators for controlling the timing around when
actions scheduled on workers are actually done.
|
<S extends Scheduler & Disposable> |
Scheduler.when(Function<Flowable<Flowable<Completable>>,Completable> combine)
Allows the use of operators for controlling the timing around when
actions scheduled on workers are actually done.
|
Modifier and Type | Class and Description |
---|---|
class |
ConnectableFlowable<T>
A
ConnectableFlowable resembles an ordinary Flowable , except that it does not begin
emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(io.reactivex.functions.Consumer<? super io.reactivex.disposables.Disposable>) method is called. |
class |
GroupedFlowable<K,T>
A
Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey() . |
Modifier and Type | Method and Description |
---|---|
Flowable<T> |
ConnectableFlowable.autoConnect()
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the first Subscriber subscribes.
|
Flowable<T> |
ConnectableFlowable.autoConnect(int numberOfSubscribers)
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the specified number of Subscribers subscribe to it.
|
Flowable<T> |
ConnectableFlowable.autoConnect(int numberOfSubscribers,
Consumer<? super Disposable> connection)
Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable
when the specified number of Subscribers subscribe to it and calls the
specified callback with the Subscription associated with the established connection.
|
Flowable<T> |
ConnectableFlowable.refCount()
Returns a
Flowable that stays connected to this ConnectableFlowable as long as there
is at least one subscription to this ConnectableFlowable . |
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 | Method and Description |
---|---|
Flowable<T> |
FuseToFlowable.fuseToFlowable()
Returns a (direct) Flowable for the operator.
|
Modifier and Type | Class and Description |
---|---|
class |
CompletableToFlowable<T> |
Modifier and Type | Class and Description |
---|---|
class |
FlowableAll<T> |
class |
FlowableAmb<T> |
class |
FlowableAny<T> |
class |
FlowableAutoConnect<T>
Wraps a
ConnectableFlowable and calls its connect() method once
the specified number of Subscriber s have subscribed. |
class |
FlowableBuffer<T,C extends Collection<? super T>> |
class |
FlowableBufferBoundary<T,U extends Collection<? super T>,Open,Close> |
class |
FlowableBufferBoundarySupplier<T,U extends Collection<? super T>,B> |
class |
FlowableBufferExactBoundary<T,U extends Collection<? super T>,B> |
class |
FlowableBufferTimed<T,U extends Collection<? super T>> |
class |
FlowableCache<T>
An observable which auto-connects to another observable, caches the elements
from that observable but allows terminating the connection and completing the cache.
|
class |
FlowableCollect<T,U> |
class |
FlowableCombineLatest<T,R>
Combines the latest values from multiple sources through a function.
|
class |
FlowableConcatArray<T> |
class |
FlowableConcatMap<T,R> |
class |
FlowableConcatMapEager<T,R> |
class |
FlowableConcatMapEagerPublisher<T,R>
ConcatMapEager which works with an arbitrary Publisher source.
|
class |
FlowableConcatMapPublisher<T,R> |
class |
FlowableConcatWithCompletable<T>
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Completable
and terminate when it terminates.
|
class |
FlowableConcatWithMaybe<T>
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Maybe,
signal its success value followed by a completion or signal its error or completion signal as is.
|
class |
FlowableConcatWithSingle<T>
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Single,
signal its success value followed by a completion or signal its error as is.
|
class |
FlowableCount<T> |
class |
FlowableCreate<T> |
class |
FlowableDebounce<T,U> |
class |
FlowableDebounceTimed<T> |
class |
FlowableDefer<T> |
class |
FlowableDelay<T> |
class |
FlowableDelaySubscriptionOther<T,U>
Delays the subscription to the main source until the other
observable fires an event or completes.
|
class |
FlowableDematerialize<T,R> |
class |
FlowableDetach<T> |
class |
FlowableDistinct<T,K> |
class |
FlowableDistinctUntilChanged<T,K> |
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 |
FlowableDoOnEach<T> |
class |
FlowableDoOnLifecycle<T> |
class |
FlowableElementAt<T> |
class |
FlowableEmpty
A source Flowable that signals an onSubscribe() + onComplete() only.
|
class |
FlowableError<T> |
class |
FlowableFilter<T> |
class |
FlowableFlatMap<T,U> |
class |
FlowableFlatMapCompletable<T>
Maps a sequence of values into CompletableSources and awaits their termination.
|
class |
FlowableFlatMapMaybe<T,R>
Maps upstream values into MaybeSources and merges their signals into one sequence.
|
class |
FlowableFlatMapPublisher<T,U> |
class |
FlowableFlatMapSingle<T,R>
Maps upstream values into SingleSources and merges their signals into one sequence.
|
class |
FlowableFlattenIterable<T,R> |
class |
FlowableFromArray<T> |
class |
FlowableFromCallable<T> |
class |
FlowableFromFuture<T> |
class |
FlowableFromIterable<T> |
class |
FlowableFromObservable<T> |
class |
FlowableFromPublisher<T> |
class |
FlowableGenerate<T,S> |
class |
FlowableGroupBy<T,K,V> |
class |
FlowableGroupJoin<TLeft,TRight,TLeftEnd,TRightEnd,R> |
class |
FlowableHide<T>
Hides the identity of the wrapped Flowable and its Subscription.
|
class |
FlowableIgnoreElements<T> |
class |
FlowableInterval |
class |
FlowableIntervalRange |
class |
FlowableJoin<TLeft,TRight,TLeftEnd,TRightEnd,R> |
class |
FlowableJust<T>
Represents a constant scalar value.
|
class |
FlowableLift<R,T>
Allows lifting operators into a chain of Publishers.
|
class |
FlowableLimit<T>
Limits both the total request amount and items received from the upstream.
|
class |
FlowableMap<T,U> |
class |
FlowableMapNotification<T,R> |
class |
FlowableMapPublisher<T,U>
Map working with an arbitrary Publisher source.
|
class |
FlowableMaterialize<T> |
class |
FlowableMergeWithCompletable<T>
Merges a Flowable and a Completable by emitting the items of the Flowable and waiting until
both the Flowable and Completable complete normally.
|
class |
FlowableMergeWithMaybe<T>
Merges an Observable and a Maybe by emitting the items of the Observable and the success
value of the Maybe and waiting until both the Observable and Maybe terminate normally.
|
class |
FlowableMergeWithSingle<T>
Merges an Observable and a Maybe by emitting the items of the Observable and the success
value of the Maybe and waiting until both the Observable and Maybe terminate normally.
|
class |
FlowableNever |
class |
FlowableObserveOn<T> |
class |
FlowableOnBackpressureBuffer<T> |
class |
FlowableOnBackpressureBufferStrategy<T>
Handle backpressure with a bounded buffer and custom strategy.
|
class |
FlowableOnBackpressureDrop<T> |
class |
FlowableOnBackpressureError<T> |
class |
FlowableOnBackpressureLatest<T> |
class |
FlowableOnErrorNext<T> |
class |
FlowableOnErrorReturn<T> |
class |
FlowablePublish<T>
A connectable observable which shares an underlying source and dispatches source values to subscribers in a backpressure-aware
manner.
|
class |
FlowablePublishMulticast<T,R>
Multicasts a Flowable over a selector function.
|
class |
FlowableRange
Emits a range of integer values.
|
class |
FlowableRangeLong
Emits a range of long values.
|
class |
FlowableReduce<T>
Reduces a sequence via a function into a single value or signals NoSuchElementException for
an empty source.
|
class |
FlowableRefCount<T>
Returns an observable sequence that stays connected to the source as long as
there is at least one subscription to the observable sequence.
|
class |
FlowableRepeat<T> |
class |
FlowableRepeatUntil<T> |
class |
FlowableRepeatWhen<T> |
class |
FlowableReplay<T> |
class |
FlowableRetryBiPredicate<T> |
class |
FlowableRetryPredicate<T> |
class |
FlowableRetryWhen<T> |
class |
FlowableSamplePublisher<T> |
class |
FlowableSampleTimed<T> |
class |
FlowableScan<T> |
class |
FlowableScanSeed<T,R> |
class |
FlowableSequenceEqual<T> |
class |
FlowableSerialized<T> |
class |
FlowableSingle<T> |
class |
FlowableSkip<T> |
class |
FlowableSkipLast<T> |
class |
FlowableSkipLastTimed<T> |
class |
FlowableSkipUntil<T,U> |
class |
FlowableSkipWhile<T> |
class |
FlowableSubscribeOn<T>
Subscribes to the source Flowable on the specified Scheduler and makes
sure downstream requests are scheduled there as well.
|
class |
FlowableSwitchIfEmpty<T> |
class |
FlowableSwitchMap<T,R> |
class |
FlowableTake<T> |
class |
FlowableTakeLast<T> |
class |
FlowableTakeLastOne<T> |
class |
FlowableTakeLastTimed<T> |
class |
FlowableTakePublisher<T>
Take with a generic Publisher source.
|
class |
FlowableTakeUntil<T,U> |
class |
FlowableTakeUntilPredicate<T> |
class |
FlowableTakeWhile<T> |
class |
FlowableThrottleFirstTimed<T> |
class |
FlowableThrottleLatest<T>
Emits the next or latest item when the given time elapses.
|
class |
FlowableTimeInterval<T> |
class |
FlowableTimeout<T,U,V> |
class |
FlowableTimeoutTimed<T> |
class |
FlowableTimer |
class |
FlowableToList<T,U extends Collection<? super T>> |
class |
FlowableUnsubscribeOn<T> |
class |
FlowableUsing<T,D> |
class |
FlowableWindow<T> |
class |
FlowableWindowBoundary<T,B> |
class |
FlowableWindowBoundarySelector<T,B,V> |
class |
FlowableWindowBoundarySupplier<T,B> |
class |
FlowableWindowTimed<T> |
class |
FlowableWithLatestFrom<T,U,R> |
class |
FlowableWithLatestFromMany<T,R>
Combines a main sequence of values with the latest from multiple other sequences via
a selector function.
|
class |
FlowableZip<T,R> |
class |
FlowableZipIterable<T,U,V> |
Modifier and Type | Field and Description |
---|---|
static Flowable<Object> |
FlowableNever.INSTANCE |
static Flowable<Object> |
FlowableEmpty.INSTANCE |
Modifier and Type | Method and Description |
---|---|
Flowable<U> |
FlowableToListSingle.fuseToFlowable() |
Flowable<T> |
FlowableSingleSingle.fuseToFlowable() |
Flowable<T> |
FlowableSingleMaybe.fuseToFlowable() |
Flowable<Boolean> |
FlowableSequenceEqualSingle.fuseToFlowable() |
Flowable<T> |
FlowableReduceMaybe.fuseToFlowable() |
Flowable<T> |
FlowableIgnoreElementsCompletable.fuseToFlowable() |
Flowable<T> |
FlowableFlatMapCompletableCompletable.fuseToFlowable() |
Flowable<T> |
FlowableElementAtSingle.fuseToFlowable() |
Flowable<T> |
FlowableElementAtMaybe.fuseToFlowable() |
Flowable<Long> |
FlowableCountSingle.fuseToFlowable() |
Flowable<U> |
FlowableCollectSingle.fuseToFlowable() |
Flowable<Boolean> |
FlowableAnySingle.fuseToFlowable() |
Flowable<Boolean> |
FlowableAllSingle.fuseToFlowable() |
static <U,R> Flowable<R> |
FlowableReplay.multicastSelector(Callable<? extends ConnectableFlowable<U>> connectableFactory,
Function<? super Flowable<U>,? extends org.reactivestreams.Publisher<R>> selector)
Given a connectable observable factory, it multicasts over the generated
ConnectableObservable via a selector function.
|
static <T,U> Flowable<U> |
FlowableScalarXMap.scalarXMap(T value,
Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper)
Maps a scalar value into a Publisher and emits its values.
|
Modifier and Type | Method and Description |
---|---|
static <T,R> Function<Flowable<T>,org.reactivestreams.Publisher<R>> |
FlowableInternalHelper.replayFunction(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
Scheduler scheduler) |
Modifier and Type | Method and Description |
---|---|
static <T> ConnectableFlowable<T> |
FlowableReplay.create(Flowable<T> source,
int bufferSize)
Creates a replaying ConnectableObservable with a size bound buffer.
|
static <T> ConnectableFlowable<T> |
FlowablePublish.create(Flowable<T> source,
int bufferSize)
Creates a OperatorPublish instance to publish values of the given source observable.
|
static <T> ConnectableFlowable<T> |
FlowableReplay.create(Flowable<T> source,
long maxAge,
TimeUnit unit,
Scheduler scheduler)
Creates a replaying ConnectableObservable with a time bound buffer.
|
static <T> ConnectableFlowable<T> |
FlowableReplay.create(Flowable<T> source,
long maxAge,
TimeUnit unit,
Scheduler scheduler,
int bufferSize)
Creates a replaying ConnectableObservable with a size and time bound buffer.
|
static <T> ConnectableFlowable<T> |
FlowableReplay.createFrom(Flowable<? extends T> source)
Creates a replaying ConnectableObservable with an unbounded buffer.
|
static <T> Callable<ConnectableFlowable<T>> |
FlowableInternalHelper.replayCallable(Flowable<T> parent) |
static <T> Callable<ConnectableFlowable<T>> |
FlowableInternalHelper.replayCallable(Flowable<T> parent,
int bufferSize) |
static <T> Callable<ConnectableFlowable<T>> |
FlowableInternalHelper.replayCallable(Flowable<T> parent,
int bufferSize,
long time,
TimeUnit unit,
Scheduler scheduler) |
static <T> Callable<ConnectableFlowable<T>> |
FlowableInternalHelper.replayCallable(Flowable<T> parent,
long time,
TimeUnit unit,
Scheduler scheduler) |
Modifier and Type | Method and Description |
---|---|
static <U,R> Flowable<R> |
FlowableReplay.multicastSelector(Callable<? extends ConnectableFlowable<U>> connectableFactory,
Function<? super Flowable<U>,? extends org.reactivestreams.Publisher<R>> selector)
Given a connectable observable factory, it multicasts over the generated
ConnectableObservable via a selector function.
|
static <T,R> Function<Flowable<T>,org.reactivestreams.Publisher<R>> |
FlowableInternalHelper.replayFunction(Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<R>> selector,
Scheduler scheduler) |
protected void |
FlowableWindowTimed.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> s) |
protected void |
FlowableWindowBoundarySupplier.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> subscriber) |
protected void |
FlowableWindowBoundarySelector.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> s) |
protected void |
FlowableWindowBoundary.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> subscriber) |
void |
FlowableWindow.subscribeActual(org.reactivestreams.Subscriber<? super Flowable<T>> s) |
Constructor and Description |
---|
BlockingFlowableIterable(Flowable<T> source,
int bufferSize) |
BlockingFlowableMostRecent(Flowable<T> source,
T initialValue) |
FlowableAll(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableAllSingle(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableAny(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableAnySingle(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableBuffer(Flowable<T> source,
int size,
int skip,
Callable<C> bufferSupplier) |
FlowableBufferBoundary(Flowable<T> source,
org.reactivestreams.Publisher<? extends Open> bufferOpen,
Function<? super Open,? extends org.reactivestreams.Publisher<? extends Close>> bufferClose,
Callable<U> bufferSupplier) |
FlowableBufferBoundarySupplier(Flowable<T> source,
Callable<? extends org.reactivestreams.Publisher<B>> boundarySupplier,
Callable<U> bufferSupplier) |
FlowableBufferExactBoundary(Flowable<T> source,
org.reactivestreams.Publisher<B> boundary,
Callable<U> bufferSupplier) |
FlowableBufferTimed(Flowable<T> source,
long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
Callable<U> bufferSupplier,
int maxSize,
boolean restartTimerOnMaxSize) |
FlowableCache(Flowable<T> source,
int capacityHint)
Constructs an empty, non-connected cache.
|
FlowableCollect(Flowable<T> source,
Callable<? extends U> initialSupplier,
BiConsumer<? super U,? super T> collector) |
FlowableCollectSingle(Flowable<T> source,
Callable<? extends U> initialSupplier,
BiConsumer<? super U,? super T> collector) |
FlowableConcatMap(Flowable<T> source,
Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch,
ErrorMode errorMode) |
FlowableConcatMapEager(Flowable<T> source,
Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int maxConcurrency,
int prefetch,
ErrorMode errorMode) |
FlowableConcatWithCompletable(Flowable<T> source,
CompletableSource other) |
FlowableConcatWithMaybe(Flowable<T> source,
MaybeSource<? extends T> other) |
FlowableConcatWithSingle(Flowable<T> source,
SingleSource<? extends T> other) |
FlowableCount(Flowable<T> source) |
FlowableCountSingle(Flowable<T> source) |
FlowableDebounce(Flowable<T> source,
Function<? super T,? extends org.reactivestreams.Publisher<U>> debounceSelector) |
FlowableDebounceTimed(Flowable<T> source,
long timeout,
TimeUnit unit,
Scheduler scheduler) |
FlowableDelay(Flowable<T> source,
long delay,
TimeUnit unit,
Scheduler scheduler,
boolean delayError) |
FlowableDematerialize(Flowable<T> source,
Function<? super T,? extends Notification<R>> selector) |
FlowableDetach(Flowable<T> source) |
FlowableDistinct(Flowable<T> source,
Function<? super T,K> keySelector,
Callable<? extends Collection<? super K>> collectionSupplier) |
FlowableDistinctUntilChanged(Flowable<T> source,
Function<? super T,K> keySelector,
BiPredicate<? super K,? super K> comparer) |
FlowableDoAfterNext(Flowable<T> source,
Consumer<? super T> onAfterNext) |
FlowableDoFinally(Flowable<T> source,
Action onFinally) |
FlowableDoOnEach(Flowable<T> source,
Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Action onAfterTerminate) |
FlowableDoOnLifecycle(Flowable<T> source,
Consumer<? super org.reactivestreams.Subscription> onSubscribe,
LongConsumer onRequest,
Action onCancel) |
FlowableElementAt(Flowable<T> source,
long index,
T defaultValue,
boolean errorOnFewer) |
FlowableElementAtMaybe(Flowable<T> source,
long index) |
FlowableElementAtSingle(Flowable<T> source,
long index,
T defaultValue) |
FlowableFilter(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableFlatMap(Flowable<T> source,
Function<? super T,? extends org.reactivestreams.Publisher<? extends U>> mapper,
boolean delayErrors,
int maxConcurrency,
int bufferSize) |
FlowableFlatMapCompletable(Flowable<T> source,
Function<? super T,? extends CompletableSource> mapper,
boolean delayErrors,
int maxConcurrency) |
FlowableFlatMapCompletableCompletable(Flowable<T> source,
Function<? super T,? extends CompletableSource> mapper,
boolean delayErrors,
int maxConcurrency) |
FlowableFlatMapMaybe(Flowable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayError,
int maxConcurrency) |
FlowableFlatMapSingle(Flowable<T> source,
Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean delayError,
int maxConcurrency) |
FlowableFlattenIterable(Flowable<T> source,
Function<? super T,? extends Iterable<? extends R>> mapper,
int prefetch) |
FlowableGroupBy(Flowable<T> source,
Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
int bufferSize,
boolean delayError,
Function<? super Consumer<Object>,? extends Map<K,Object>> mapFactory) |
FlowableGroupJoin(Flowable<TLeft> source,
org.reactivestreams.Publisher<? extends TRight> other,
Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
BiFunction<? super TLeft,? super Flowable<TRight>,? extends R> resultSelector) |
FlowableHide(Flowable<T> source) |
FlowableIgnoreElements(Flowable<T> source) |
FlowableIgnoreElementsCompletable(Flowable<T> source) |
FlowableJoin(Flowable<TLeft> source,
org.reactivestreams.Publisher<? extends TRight> other,
Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
BiFunction<? super TLeft,? super TRight,? extends R> resultSelector) |
FlowableLift(Flowable<T> source,
FlowableOperator<? extends R,? super T> operator) |
FlowableLimit(Flowable<T> source,
long n) |
FlowableMap(Flowable<T> source,
Function<? super T,? extends U> mapper) |
FlowableMapNotification(Flowable<T> source,
Function<? super T,? extends R> onNextMapper,
Function<? super Throwable,? extends R> onErrorMapper,
Callable<? extends R> onCompleteSupplier) |
FlowableMaterialize(Flowable<T> source) |
FlowableMergeWithCompletable(Flowable<T> source,
CompletableSource other) |
FlowableMergeWithMaybe(Flowable<T> source,
MaybeSource<? extends T> other) |
FlowableMergeWithSingle(Flowable<T> source,
SingleSource<? extends T> other) |
FlowableObserveOn(Flowable<T> source,
Scheduler scheduler,
boolean delayError,
int prefetch) |
FlowableOnBackpressureBuffer(Flowable<T> source,
int bufferSize,
boolean unbounded,
boolean delayError,
Action onOverflow) |
FlowableOnBackpressureBufferStrategy(Flowable<T> source,
long bufferSize,
Action onOverflow,
BackpressureOverflowStrategy strategy) |
FlowableOnBackpressureDrop(Flowable<T> source) |
FlowableOnBackpressureDrop(Flowable<T> source,
Consumer<? super T> onDrop) |
FlowableOnBackpressureError(Flowable<T> source) |
FlowableOnBackpressureLatest(Flowable<T> source) |
FlowableOnErrorNext(Flowable<T> source,
Function<? super Throwable,? extends org.reactivestreams.Publisher<? extends T>> nextSupplier,
boolean allowFatal) |
FlowableOnErrorReturn(Flowable<T> source,
Function<? super Throwable,? extends T> valueSupplier) |
FlowablePublishMulticast(Flowable<T> source,
Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>> selector,
int prefetch,
boolean delayError) |
FlowableReduce(Flowable<T> source,
BiFunction<T,T,T> reducer) |
FlowableReduceMaybe(Flowable<T> source,
BiFunction<T,T,T> reducer) |
FlowableRepeat(Flowable<T> source,
long count) |
FlowableRepeatUntil(Flowable<T> source,
BooleanSupplier until) |
FlowableRepeatWhen(Flowable<T> source,
Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler) |
FlowableRetryBiPredicate(Flowable<T> source,
BiPredicate<? super Integer,? super Throwable> predicate) |
FlowableRetryPredicate(Flowable<T> source,
long count,
Predicate<? super Throwable> predicate) |
FlowableRetryWhen(Flowable<T> source,
Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler) |
FlowableSampleTimed(Flowable<T> source,
long period,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast) |
FlowableScan(Flowable<T> source,
BiFunction<T,T,T> accumulator) |
FlowableScanSeed(Flowable<T> source,
Callable<R> seedSupplier,
BiFunction<R,? super T,R> accumulator) |
FlowableSerialized(Flowable<T> source) |
FlowableSingle(Flowable<T> source,
T defaultValue,
boolean failOnEmpty) |
FlowableSingleMaybe(Flowable<T> source) |
FlowableSingleSingle(Flowable<T> source,
T defaultValue) |
FlowableSkip(Flowable<T> source,
long n) |
FlowableSkipLast(Flowable<T> source,
int skip) |
FlowableSkipLastTimed(Flowable<T> source,
long time,
TimeUnit unit,
Scheduler scheduler,
int bufferSize,
boolean delayError) |
FlowableSkipUntil(Flowable<T> source,
org.reactivestreams.Publisher<U> other) |
FlowableSkipWhile(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableSubscribeOn(Flowable<T> source,
Scheduler scheduler,
boolean nonScheduledRequests) |
FlowableSwitchIfEmpty(Flowable<T> source,
org.reactivestreams.Publisher<? extends T> other) |
FlowableSwitchMap(Flowable<T> source,
Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int bufferSize,
boolean delayErrors) |
FlowableTake(Flowable<T> source,
long limit) |
FlowableTakeLast(Flowable<T> source,
int count) |
FlowableTakeLastOne(Flowable<T> source) |
FlowableTakeLastTimed(Flowable<T> source,
long count,
long time,
TimeUnit unit,
Scheduler scheduler,
int bufferSize,
boolean delayError) |
FlowableTakeUntil(Flowable<T> source,
org.reactivestreams.Publisher<? extends U> other) |
FlowableTakeUntilPredicate(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableTakeWhile(Flowable<T> source,
Predicate<? super T> predicate) |
FlowableThrottleFirstTimed(Flowable<T> source,
long timeout,
TimeUnit unit,
Scheduler scheduler) |
FlowableThrottleLatest(Flowable<T> source,
long timeout,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast) |
FlowableTimeInterval(Flowable<T> source,
TimeUnit unit,
Scheduler scheduler) |
FlowableTimeout(Flowable<T> source,
org.reactivestreams.Publisher<U> firstTimeoutIndicator,
Function<? super T,? extends org.reactivestreams.Publisher<V>> itemTimeoutIndicator,
org.reactivestreams.Publisher<? extends T> other) |
FlowableTimeoutTimed(Flowable<T> source,
long timeout,
TimeUnit unit,
Scheduler scheduler,
org.reactivestreams.Publisher<? extends T> other) |
FlowableToList(Flowable<T> source,
Callable<U> collectionSupplier) |
FlowableToListSingle(Flowable<T> source) |
FlowableToListSingle(Flowable<T> source,
Callable<U> collectionSupplier) |
FlowableUnsubscribeOn(Flowable<T> source,
Scheduler scheduler) |
FlowableWindow(Flowable<T> source,
long size,
long skip,
int bufferSize) |
FlowableWindowBoundary(Flowable<T> source,
org.reactivestreams.Publisher<B> other,
int capacityHint) |
FlowableWindowBoundarySelector(Flowable<T> source,
org.reactivestreams.Publisher<B> open,
Function<? super B,? extends org.reactivestreams.Publisher<V>> close,
int bufferSize) |
FlowableWindowBoundarySupplier(Flowable<T> source,
Callable<? extends org.reactivestreams.Publisher<B>> other,
int capacityHint) |
FlowableWindowTimed(Flowable<T> source,
long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
long maxSize,
int bufferSize,
boolean restartTimerOnMaxSize) |
FlowableWithLatestFrom(Flowable<T> source,
BiFunction<? super T,? super U,? extends R> combiner,
org.reactivestreams.Publisher<? extends U> other) |
FlowableWithLatestFromMany(Flowable<T> source,
Iterable<? extends org.reactivestreams.Publisher<?>> otherIterable,
Function<? super Object[],R> combiner) |
FlowableWithLatestFromMany(Flowable<T> source,
org.reactivestreams.Publisher<?>[] otherArray,
Function<? super Object[],R> combiner) |
FlowableZipIterable(Flowable<T> source,
Iterable<U> other,
BiFunction<? super T,? super U,? extends V> zipper) |
Constructor and Description |
---|
FlowableGroupJoin(Flowable<TLeft> source,
org.reactivestreams.Publisher<? extends TRight> other,
Function<? super TLeft,? extends org.reactivestreams.Publisher<TLeftEnd>> leftEnd,
Function<? super TRight,? extends org.reactivestreams.Publisher<TRightEnd>> rightEnd,
BiFunction<? super TLeft,? super Flowable<TRight>,? extends R> resultSelector) |
FlowablePublishMulticast(Flowable<T> source,
Function<? super Flowable<T>,? extends org.reactivestreams.Publisher<? extends R>> selector,
int prefetch,
boolean delayError) |
FlowableRepeatWhen(Flowable<T> source,
Function<? super Flowable<Object>,? extends org.reactivestreams.Publisher<?>> handler) |
FlowableRetryWhen(Flowable<T> source,
Function<? super Flowable<Throwable>,? extends org.reactivestreams.Publisher<?>> handler) |
Modifier and Type | Class and Description |
---|---|
class |
MaybeConcatArray<T>
Concatenate values of each MaybeSource provided in an array.
|
class |
MaybeConcatArrayDelayError<T>
Concatenate values of each MaybeSource provided in an array and delays
any errors till the very end.
|
class |
MaybeConcatIterable<T>
Concatenate values of each MaybeSource provided by an Iterable.
|
class |
MaybeFlatMapIterableFlowable<T,R>
Maps a success value into an Iterable and streams it back as a Flowable.
|
class |
MaybeMergeArray<T>
Run all MaybeSources of an array at once and signal their values as they become available.
|
class |
MaybeToFlowable<T>
Wraps a MaybeSource and exposes it as a Flowable, relaying signals in a backpressure-aware manner
and composes cancellation through.
|
Modifier and Type | Class and Description |
---|---|
class |
CompletableAndThenPublisher<R>
After Completable completes, it relays the signals
of the Publisher to the downstream subscriber.
|
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 |
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 |
MaybeFlatMapPublisher<T,R>
Maps the success value of a Maybe onto a Publisher and
relays its signals to the downstream subscriber.
|
Constructor and Description |
---|
FlowableConcatMapCompletable(Flowable<T> source,
Function<? super T,? extends CompletableSource> mapper,
ErrorMode errorMode,
int prefetch) |
FlowableConcatMapMaybe(Flowable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
ErrorMode errorMode,
int prefetch) |
FlowableConcatMapSingle(Flowable<T> source,
Function<? super T,? extends SingleSource<? extends R>> mapper,
ErrorMode errorMode,
int prefetch) |
FlowableSwitchMapCompletable(Flowable<T> source,
Function<? super T,? extends CompletableSource> mapper,
boolean delayErrors) |
FlowableSwitchMapMaybe(Flowable<T> source,
Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors) |
FlowableSwitchMapSingle(Flowable<T> source,
Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean delayErrors) |
Modifier and Type | Class and Description |
---|---|
class |
ParallelJoin<T>
Merges the individual 'rails' of the source ParallelFlowable, unordered,
into a single regular Publisher sequence (exposed as Flowable).
|
class |
ParallelReduceFull<T>
Reduces all 'rails' into a single value which then gets reduced into a single
Publisher sequence.
|
class |
ParallelSortedJoin<T>
Given sorted rail sequences (according to the provided comparator) as List
emit the smallest item from these parallel Lists to the Subscriber.
|
Modifier and Type | Class and Description |
---|---|
class |
SingleFlatMapIterableFlowable<T,R>
Maps a success value into an Iterable and streams it back as a Flowable.
|
class |
SingleFlatMapPublisher<T,R>
A Flowable that emits items based on applying a specified function to the item emitted by the
source Single, where that function returns a Publisher.
|
class |
SingleToFlowable<T>
Wraps a Single and exposes it as a Flowable.
|
Modifier and Type | Method and Description |
---|---|
static <T> Iterable<? extends Flowable<T>> |
SingleInternalHelper.iterableToFlowable(Iterable<? extends SingleSource<? extends T>> sources) |
Constructor and Description |
---|
SchedulerWhen(Function<Flowable<Flowable<Completable>>,Completable> combine,
Scheduler actualScheduler) |
SchedulerWhen(Function<Flowable<Flowable<Completable>>,Completable> combine,
Scheduler actualScheduler) |
Modifier and Type | Method and Description |
---|---|
Flowable<T> |
ParallelFlowable.reduce(BiFunction<T,T,T> reducer)
Reduces all values within a 'rail' and across 'rails' with a reducer function into a single
sequential value.
|
Flowable<T> |
ParallelFlowable.sequential()
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Publisher sequence, running with a default prefetch value
for the rails.
|
Flowable<T> |
ParallelFlowable.sequential(int prefetch)
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Publisher sequence, running with a give prefetch value
for the rails.
|
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.
|
Flowable<T> |
ParallelFlowable.sequentialDelayError(int prefetch)
Merges the values from each 'rail' in a round-robin or same-order fashion and
exposes it as a regular Publisher sequence, running with a give prefetch value
for the rails and delaying errors from all rails till all terminate.
|
Flowable<T> |
ParallelFlowable.sorted(Comparator<? super T> comparator)
Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially
picks the smallest next value from the rails.
|
Flowable<T> |
ParallelFlowable.sorted(Comparator<? super T> comparator,
int capacityHint)
Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially
picks the smallest next value from the rails.
|
Flowable<List<T>> |
ParallelFlowable.toSortedList(Comparator<? super T> comparator)
Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
|
Flowable<List<T>> |
ParallelFlowable.toSortedList(Comparator<? super T> comparator,
int capacityHint)
Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
|
Modifier and Type | Method and Description |
---|---|
static <T> Flowable<T> |
RxJavaPlugins.onAssembly(Flowable<T> source)
Calls the associated hook function.
|
Modifier and Type | Method and Description |
---|---|
static Function<? super Flowable,? extends Flowable> |
RxJavaPlugins.getOnFlowableAssembly()
Returns the current hook function.
|
static Function<? super Flowable,? extends Flowable> |
RxJavaPlugins.getOnFlowableAssembly()
Returns the current hook function.
|
static BiFunction<? super Flowable,? super org.reactivestreams.Subscriber,? extends org.reactivestreams.Subscriber> |
RxJavaPlugins.getOnFlowableSubscribe()
Returns the current hook function.
|
Modifier and Type | Method and Description |
---|---|
static <T> Flowable<T> |
RxJavaPlugins.onAssembly(Flowable<T> source)
Calls the associated hook function.
|
static <T> org.reactivestreams.Subscriber<? super T> |
RxJavaPlugins.onSubscribe(Flowable<T> source,
org.reactivestreams.Subscriber<? super T> subscriber)
Calls the associated hook function.
|
Modifier and Type | Method and Description |
---|---|
static void |
RxJavaPlugins.setOnFlowableAssembly(Function<? super Flowable,? extends Flowable> onFlowableAssembly)
Sets the specific hook function.
|
static void |
RxJavaPlugins.setOnFlowableAssembly(Function<? super Flowable,? extends Flowable> onFlowableAssembly)
Sets the specific hook function.
|
static void |
RxJavaPlugins.setOnFlowableSubscribe(BiFunction<? super Flowable,? super org.reactivestreams.Subscriber,? extends org.reactivestreams.Subscriber> onFlowableSubscribe)
Sets the specific hook function.
|
Modifier and Type | Class and Description |
---|---|
class |
AsyncProcessor<T>
Processor that emits the very last value followed by a completion event or the received error
to
Subscriber s. |
class |
BehaviorProcessor<T>
Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed
Subscriber . |
class |
FlowableProcessor<T>
Represents a Subscriber and a Flowable (Publisher) at the same time, allowing
multicasting events from a single source to multiple child Subscribers.
|
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. |
class |
PublishProcessor<T>
Processor that multicasts all subsequently observed items to its current
Subscriber s. |
class |
ReplayProcessor<T>
Replays events to Subscribers.
|
class |
UnicastProcessor<T>
A
FlowableProcessor variant that queues up events until a single Subscriber subscribes to it, replays
those events to it until the Subscriber catches up and then switches to relaying events live to
this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels
its subscription. |
Copyright © 2019. All rights reserved.