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.observables |
Classes supporting the Observable base reactive class:
ConnectableObservable and
GroupedObservable . |
io.reactivex.parallel |
Contains the base type
ParallelFlowable ,
a sub-DSL for working with Flowable sequences in parallel. |
io.reactivex.processors |
Classes extending the Flowable base reactive class and implementing
the Subscriber interface at the same time (aka hot Flowables).
|
Modifier and Type | Method and Description |
---|---|
Single<Boolean> |
Flowable.all(Predicate<? super T> predicate)
Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source
Publisher satisfy a condition.
|
Single<Boolean> |
Observable.all(Predicate<? super T> predicate)
Returns a Single that emits a Boolean that indicates whether all of the items emitted by the source
ObservableSource satisfy a condition.
|
static Completable |
Completable.amb(Iterable<? extends CompletableSource> sources)
Returns a Completable which terminates as soon as one of the source Completables
terminates (normally or with an error) and cancels all other Completables.
|
static <T> Maybe<T> |
Maybe.amb(Iterable<? extends MaybeSource<? extends T>> sources)
Runs multiple MaybeSources and signals the events of the first one that signals (cancelling
the rest).
|
static <T> Observable<T> |
Observable.amb(Iterable<? extends ObservableSource<? extends T>> sources)
Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends
a termination notification.
|
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> Single<T> |
Single.amb(Iterable<? extends SingleSource<? extends T>> sources)
Runs multiple SingleSources and signals the events of the first one that signals (cancelling
the rest).
|
static Completable |
Completable.ambArray(CompletableSource... sources)
Returns a Completable which terminates as soon as one of the source Completables
terminates (normally or with an error) and cancels all other Completables.
|
static <T> Maybe<T> |
Maybe.ambArray(MaybeSource<? extends T>... sources)
Runs multiple MaybeSources and signals the events of the first one that signals (cancelling
the rest).
|
static <T> Observable<T> |
Observable.ambArray(ObservableSource<? extends T>... sources)
Mirrors the one ObservableSource in an array of several ObservableSources 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.
|
static <T> Single<T> |
Single.ambArray(SingleSource<? extends T>... sources)
Runs multiple SingleSources and signals the events of the first one that signals (cancelling
the rest).
|
Completable |
Completable.ambWith(CompletableSource other)
Returns a Completable that emits the a terminated event of either this Completable
or the other Completable whichever fires first.
|
Maybe<T> |
Maybe.ambWith(MaybeSource<? extends T> other)
Mirrors the MaybeSource (current or provided) that first signals an event.
|
Observable<T> |
Observable.ambWith(ObservableSource<? extends T> other)
Mirrors the ObservableSource (current or provided) 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.
|
Single<T> |
Single.ambWith(SingleSource<? extends T> other)
Signals the event of this or the other SingleSource whichever signals first.
|
Completable |
Completable.andThen(CompletableSource next)
Returns a Completable that first runs this Completable
and then the other completable.
|
<T> Maybe<T> |
Completable.andThen(MaybeSource<T> next)
Returns a
Maybe which will subscribe to this Completable and once that is completed then
will subscribe to the next MaybeSource. |
<T> Observable<T> |
Completable.andThen(ObservableSource<T> next)
Returns an Observable which will subscribe to this Completable and once that is completed then
will subscribe to the
next ObservableSource. |
<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. |
<T> Single<T> |
Completable.andThen(SingleSource<T> next)
Returns a Single which will subscribe to this Completable and once that is completed then
will subscribe to the
next SingleSource. |
Single<Boolean> |
Flowable.any(Predicate<? super T> predicate)
Returns a Single that emits
true if any item emitted by the source Publisher satisfies a
specified condition, otherwise false . |
Single<Boolean> |
Observable.any(Predicate<? super T> predicate)
Returns a Single that emits
true if any item emitted by the source ObservableSource satisfies a
specified condition, otherwise false . |
<R> R |
Completable.as(CompletableConverter<? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Flowable.as(FlowableConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Maybe.as(MaybeConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Observable.as(ObservableConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Single.as(SingleConverter<T,? extends R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
void |
Completable.blockingAwait()
Subscribes to and awaits the termination of this Completable instance in a blocking manner and
rethrows any exception emitted.
|
boolean |
Completable.blockingAwait(long timeout,
TimeUnit unit)
Subscribes to and awaits the termination of this Completable instance in a blocking manner
with a specific timeout and rethrows any exception emitted within the timeout window.
|
T |
Flowable.blockingFirst()
Returns the first item emitted by this
Flowable , or throws
NoSuchElementException if it emits no items. |
T |
Observable.blockingFirst()
Returns the first item emitted by this
Observable , or throws
NoSuchElementException if it emits no items. |
T |
Flowable.blockingFirst(T defaultItem)
Returns the first item emitted by this
Flowable , or a default value if it emits no
items. |
T |
Observable.blockingFirst(T defaultItem)
Returns the first item emitted by this
Observable , or a default value if it emits no
items. |
void |
Flowable.blockingForEach(Consumer<? super T> onNext)
Consumes the upstream
Flowable in a blocking fashion and invokes the given
Consumer with each upstream item on the current thread until the
upstream terminates. |
void |
Observable.blockingForEach(Consumer<? super T> onNext)
Consumes the upstream
Observable in a blocking fashion and invokes the given
Consumer with each upstream item on the current thread until the
upstream terminates. |
Throwable |
Completable.blockingGet()
Subscribes to this Completable instance and blocks until it terminates, then returns null or
the emitted exception if any.
|
T |
Maybe.blockingGet()
Waits in a blocking fashion until the current Maybe signals a success value (which is returned),
null if completed or an exception (which is propagated).
|
T |
Single.blockingGet()
Waits in a blocking fashion until the current Single signals a success value (which is returned) or
an exception (which is propagated).
|
Throwable |
Completable.blockingGet(long timeout,
TimeUnit unit)
Subscribes to this Completable instance and blocks until it terminates or the specified timeout
elapses, then returns null for normal termination or the emitted exception if any.
|
T |
Maybe.blockingGet(T defaultValue)
Waits in a blocking fashion until the current Maybe signals a success value (which is returned),
defaultValue if completed or an exception (which is propagated).
|
Iterable<T> |
Flowable.blockingIterable()
Converts this
Flowable into an Iterable . |
Iterable<T> |
Observable.blockingIterable()
Converts this
Observable into an Iterable . |
Iterable<T> |
Flowable.blockingIterable(int bufferSize)
Converts this
Flowable into an Iterable . |
Iterable<T> |
Observable.blockingIterable(int bufferSize)
Converts this
Observable into an Iterable . |
T |
Flowable.blockingLast()
Returns the last item emitted by this
Flowable , or throws
NoSuchElementException if this Flowable emits no items. |
T |
Observable.blockingLast()
Returns the last item emitted by this
Observable , or throws
NoSuchElementException if this Observable emits no items. |
T |
Flowable.blockingLast(T defaultItem)
Returns the last item emitted by this
Flowable , or a default value if it emits no
items. |
T |
Observable.blockingLast(T defaultItem)
Returns the last item emitted by this
Observable , or a default value if it emits no
items. |
Iterable<T> |
Flowable.blockingLatest()
Returns an
Iterable that returns the latest item emitted by this Flowable ,
waiting if necessary for one to become available. |
Iterable<T> |
Observable.blockingLatest()
Returns an
Iterable that returns the latest item emitted by this Observable ,
waiting if necessary for one to become available. |
Iterable<T> |
Flowable.blockingMostRecent(T initialItem)
Returns an
Iterable that always returns the item most recently emitted by this
Flowable . |
Iterable<T> |
Observable.blockingMostRecent(T initialValue)
Returns an
Iterable that always returns the item most recently emitted by this
Observable . |
Iterable<T> |
Flowable.blockingNext()
Returns an
Iterable that blocks until this Flowable emits another item, then
returns that item. |
Iterable<T> |
Observable.blockingNext()
Returns an
Iterable that blocks until this Observable emits another item, then
returns that item. |
T |
Flowable.blockingSingle()
If this
Flowable completes after emitting a single item, return that item, otherwise
throw a NoSuchElementException . |
T |
Observable.blockingSingle()
If this
Observable completes after emitting a single item, return that item, otherwise
throw a NoSuchElementException . |
T |
Flowable.blockingSingle(T defaultItem)
If this
Flowable completes after emitting a single item, return that item; if it emits
more than one item, throw an IllegalArgumentException ; if it emits no items, return a default
value. |
T |
Observable.blockingSingle(T defaultItem)
If this
Observable completes after emitting a single item, return that item; if it emits
more than one item, throw an IllegalArgumentException ; if it emits no items, return a default
value. |
void |
Flowable.blockingSubscribe()
Runs the source Flowable to a terminal event, ignoring any values and rethrowing any exception.
|
void |
Observable.blockingSubscribe()
Runs the source observable to a terminal event, ignoring any values and rethrowing any exception.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Observable.blockingSubscribe(Consumer<? super T> onNext)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Observable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Observable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
int bufferSize)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
int bufferSize)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Flowable.blockingSubscribe(Consumer<? super T> onNext,
int bufferSize)
Subscribes to the source and calls the given callbacks on the current thread.
|
void |
Observable.blockingSubscribe(Observer<? super T> observer)
Subscribes to the source and calls the
Observer methods on the current thread. |
void |
Flowable.blockingSubscribe(org.reactivestreams.Subscriber<? super T> subscriber)
Subscribes to the source and calls the
Subscriber methods on the current thread. |
<B> Observable<List<T>> |
Observable.buffer(Callable<? extends ObservableSource<B>> boundarySupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<B,U extends Collection<? super T>> |
Observable.buffer(Callable<? extends ObservableSource<B>> boundarySupplier,
Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<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.
|
Observable<List<T>> |
Observable.buffer(int count)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<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.
|
<U extends Collection<? super T>> |
Observable.buffer(int count,
Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
Flowable<List<T>> |
Flowable.buffer(int count,
int skip)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Observable<List<T>> |
Observable.buffer(int count,
int skip)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<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.
|
<U extends Collection<? super T>> |
Observable.buffer(int count,
int skip,
Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
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.
|
Observable<List<T>> |
Observable.buffer(long timespan,
long timeskip,
TimeUnit unit)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
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.
|
Observable<List<T>> |
Observable.buffer(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<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.
|
<U extends Collection<? super T>> |
Observable.buffer(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
Flowable<List<T>> |
Flowable.buffer(long timespan,
TimeUnit unit)
Returns a Flowable that emits buffers of items it collects from the source Publisher.
|
Observable<List<T>> |
Observable.buffer(long timespan,
TimeUnit unit)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
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.
|
Observable<List<T>> |
Observable.buffer(long timespan,
TimeUnit unit,
int count)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
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.
|
Observable<List<T>> |
Observable.buffer(long timespan,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
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.
|
Observable<List<T>> |
Observable.buffer(long timespan,
TimeUnit unit,
Scheduler scheduler,
int count)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<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.
|
<U extends Collection<? super T>> |
Observable.buffer(long timespan,
TimeUnit unit,
Scheduler scheduler,
int count,
Callable<U> bufferSupplier,
boolean restartTimerOnMaxSize)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<TOpening,TClosing> |
Observable.buffer(ObservableSource<? extends TOpening> openingIndicator,
Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<TOpening,TClosing,U extends Collection<? super T>> |
Observable.buffer(ObservableSource<? extends TOpening> openingIndicator,
Function<? super TOpening,? extends ObservableSource<? extends TClosing>> closingIndicator,
Callable<U> bufferSupplier)
Returns an Observable that emits buffers of items it collects from the source ObservableSource.
|
<B> Observable<List<T>> |
Observable.buffer(ObservableSource<B> boundary)
Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the
specified boundary ObservableSource emits an item.
|
<B,U extends Collection<? super T>> |
Observable.buffer(ObservableSource<B> boundary,
Callable<U> bufferSupplier)
Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the
specified boundary ObservableSource emits an item.
|
<B> Observable<List<T>> |
Observable.buffer(ObservableSource<B> boundary,
int initialCapacity)
Returns an Observable that emits non-overlapping buffered items from the source ObservableSource each time the
specified boundary ObservableSource emits an item.
|
<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.
|
Completable |
Completable.cache()
Subscribes to this Completable only once, when the first CompletableObserver
subscribes to the result Completable, caches its terminal event
and relays/replays it to observers.
|
Maybe<T> |
Maybe.cache()
Returns a Maybe that subscribes to this Maybe lazily, caches its event
and replays it, to all the downstream subscribers.
|
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.
|
Single<T> |
Single.cache()
Stores the success value or exception from the current Single and replays it to late SingleObservers.
|
Observable<T> |
Observable.cache()
Returns an Observable that subscribes to this ObservableSource 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.
|
Observable<T> |
Observable.cacheWithInitialCapacity(int initialCapacity)
Returns an Observable that subscribes to this ObservableSource lazily, caches all of its events
and replays them, in the same order as received, to all the downstream subscribers.
|
<U> Maybe<U> |
Maybe.cast(Class<? extends U> clazz)
Casts the success value of the current Maybe into the target type or signals a
ClassCastException if not compatible.
|
<U> Single<U> |
Single.cast(Class<? extends U> clazz)
Casts the success value of the current Single into the target type or signals a
ClassCastException if not compatible.
|
<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.
|
<U> Observable<U> |
Observable.cast(Class<U> clazz)
Returns an Observable that emits the items emitted by the source ObservableSource, converted to the specified
type.
|
<U> Single<U> |
Flowable.collect(Callable<? extends U> initialItemSupplier,
BiConsumer<? super U,? super T> collector)
Collects items emitted by the finite source Publisher into a single mutable data structure and returns
a Single that emits this structure.
|
<U> Single<U> |
Observable.collect(Callable<? extends U> initialValueSupplier,
BiConsumer<? super U,? super T> collector)
Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns
a Single that emits this structure.
|
<U> Single<U> |
Flowable.collectInto(U initialItem,
BiConsumer<? super U,? super T> collector)
Collects items emitted by the finite source Publisher into a single mutable data structure and returns
a Single that emits this structure.
|
<U> Single<U> |
Observable.collectInto(U initialValue,
BiConsumer<? super U,? super T> collector)
Collects items emitted by the finite source ObservableSource into a single mutable data structure and returns
a Single that emits this structure.
|
static <T,R> Observable<R> |
Observable.combineLatest(Function<? super Object[],? extends R> combiner,
int bufferSize,
ObservableSource<? extends T>... sources)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
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> Observable<R> |
Observable.combineLatest(Iterable<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T,R> Observable<R> |
Observable.combineLatest(Iterable<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, 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> Observable<R> |
Observable.combineLatest(ObservableSource<? extends T>[] sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T,R> Observable<R> |
Observable.combineLatest(ObservableSource<? extends T>[] sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,R> Observable<R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> combiner)
Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from either of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
Function3<? super T1,? super T2,? super T3,? extends R> combiner)
Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
Function4<? super T1,? super T2,? super T3,? super T4,? extends R> combiner)
Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> combiner)
Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> combiner)
Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
ObservableSource<? extends T7> source7,
Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> combiner)
Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
ObservableSource<? extends T7> source7,
ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Observable.combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
ObservableSource<? extends T7> source7,
ObservableSource<? extends T8> source8,
ObservableSource<? 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 ObservableSources by emitting an item that aggregates the latest values of each of the
source ObservableSources each time an item is received from any of the source ObservableSources, 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> Observable<R> |
Observable.combineLatestDelayError(Function<? super Object[],? extends R> combiner,
int bufferSize,
ObservableSource<? extends T>... sources)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSources terminate.
|
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> Observable<R> |
Observable.combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSources terminate.
|
static <T,R> Observable<R> |
Observable.combineLatestDelayError(Iterable<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSources 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> Observable<R> |
Observable.combineLatestDelayError(ObservableSource<? extends T>[] sources,
Function<? super Object[],? extends R> combiner)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function.
|
static <T,R> Observable<R> |
Observable.combineLatestDelayError(ObservableSource<? extends T>[] sources,
Function<? super Object[],? extends R> combiner,
int bufferSize)
Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of
the source ObservableSources each time an item is received from any of the source ObservableSources, where this
aggregation is defined by a specified function and delays any error from the sources until
all source ObservableSources 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.
|
static Completable |
Completable.complete()
Returns a Completable instance that completes immediately when subscribed to.
|
Completable |
Completable.compose(CompletableTransformer transformer)
Calls the given transformer function with this instance and returns the function's resulting
Completable.
|
<R> Flowable<R> |
Flowable.compose(FlowableTransformer<? super T,? extends R> composer)
Transform a Publisher by applying a particular Transformer function to it.
|
<R> Maybe<R> |
Maybe.compose(MaybeTransformer<? super T,? extends R> transformer)
Transform a Maybe by applying a particular Transformer function to it.
|
<R> Observable<R> |
Observable.compose(ObservableTransformer<? super T,? extends R> composer)
Transform an ObservableSource by applying a particular Transformer function to it.
|
<R> Single<R> |
Single.compose(SingleTransformer<? super T,? extends R> transformer)
Transform a Single by applying a particular Transformer function to it.
|
static Completable |
Completable.concat(Iterable<? extends CompletableSource> sources)
Returns a Completable which completes only when all sources complete, one after another.
|
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> Observable<T> |
Observable.concat(Iterable<? extends ObservableSource<? extends T>> sources)
Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence
of elements without interleaving them.
|
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> Observable<T> |
Observable.concat(ObservableSource<? extends ObservableSource<? extends T>> sources)
Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source
ObservableSource, one after the other, without interleaving them.
|
static <T> Observable<T> |
Observable.concat(ObservableSource<? extends ObservableSource<? extends T>> sources,
int prefetch)
Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the source
ObservableSource, one after the other, without interleaving them.
|
static <T> Observable<T> |
Single.concat(ObservableSource<? extends SingleSource<? extends T>> sources)
Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by
an Observable sequence.
|
static <T> Observable<T> |
Observable.concat(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2)
Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without
interleaving them.
|
static <T> Observable<T> |
Observable.concat(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3)
Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without
interleaving them.
|
static <T> Observable<T> |
Observable.concat(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3,
ObservableSource<? extends T> source4)
Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without
interleaving them.
|
static Completable |
Completable.concat(org.reactivestreams.Publisher<? extends CompletableSource> sources)
Returns a Completable which completes only when all sources complete, one after another.
|
static Completable |
Completable.concat(org.reactivestreams.Publisher<? extends CompletableSource> sources,
int prefetch)
Returns a Completable which completes only when all sources complete, one after another.
|
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 Completable |
Completable.concatArray(CompletableSource... sources)
Returns a Completable which completes only when all sources complete, one after another.
|
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> Observable<T> |
Observable.concatArray(ObservableSource<? extends T>... sources)
Concatenates a variable number of ObservableSource sources.
|
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> Observable<T> |
Observable.concatArrayDelayError(ObservableSource<? extends T>... sources)
Concatenates a variable number of ObservableSource 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> Observable<T> |
Observable.concatArrayEager(int maxConcurrency,
int prefetch,
ObservableSource<? extends T>... sources)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
|
static <T> Flowable<T> |
Flowable.concatArrayEager(int maxConcurrency,
int prefetch,
org.reactivestreams.Publisher<? extends T>... sources)
Concatenates a sequence 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> Observable<T> |
Observable.concatArrayEager(ObservableSource<? extends T>... sources)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
|
static <T> Flowable<T> |
Flowable.concatArrayEager(org.reactivestreams.Publisher<? extends T>... sources)
Concatenates a sequence 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> |
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> Observable<T> |
Observable.concatDelayError(Iterable<? extends ObservableSource<? extends T>> sources)
Concatenates the Iterable sequence of ObservableSources into a single sequence by subscribing to each ObservableSource,
one after the other, one at a time and delays any errors till the all inner ObservableSources 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> Observable<T> |
Observable.concatDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources)
Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource,
one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
|
static <T> Observable<T> |
Observable.concatDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources,
int prefetch,
boolean tillTheEnd)
Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource,
one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.
|
static <T> 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> Observable<T> |
Observable.concatEager(Iterable<? extends ObservableSource<? extends T>> sources)
Concatenates a sequence of ObservableSources eagerly into a single stream of values.
|
static <T> Observable<T> |
Observable.concatEager(Iterable<? extends ObservableSource<? extends T>> sources,
int maxConcurrency,
int prefetch)
Concatenates a sequence of ObservableSources 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> Observable<T> |
Observable.concatEager(ObservableSource<? extends ObservableSource<? extends T>> sources)
Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.
|
static <T> Observable<T> |
Observable.concatEager(ObservableSource<? extends ObservableSource<? extends T>> sources,
int maxConcurrency,
int prefetch)
Concatenates an ObservableSource sequence of ObservableSources 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> Maybe<R> |
Maybe.concatMap(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe,
where that function returns a MaybeSource.
|
<R> Observable<R> |
Observable.concatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns a new Observable that emits items resulting from applying a function that you supply to each item
emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items
that result from concatenating those resulting ObservableSources.
|
<R> Observable<R> |
Observable.concatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int prefetch)
Returns a new Observable that emits items resulting from applying a function that you supply to each item
emitted by the source ObservableSource, where that function returns an ObservableSource, and then emitting the items
that result from concatenating those resulting ObservableSources.
|
<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.
|
Completable |
Flowable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other completes. |
Completable |
Observable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in
order and waits until the upstream and all CompletableSources complete.
|
Completable |
Flowable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
int prefetch)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other completes. |
Completable |
Observable.concatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
int capacityHint)
Maps each element of the upstream Observable into CompletableSources, subscribes to them one at a time in
order and waits until the upstream and all CompletableSources complete.
|
Completable |
Flowable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, delaying all errors till both this Flowable and all
inner CompletableSource s terminate. |
Completable |
Observable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, delaying all errors till both this Observable and all
inner CompletableSource s terminate. |
Completable |
Flowable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Flowable and all
inner CompletableSource s terminate. |
Completable |
Observable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Observable and all
inner CompletableSource s terminate. |
Completable |
Flowable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Flowable and all
inner CompletableSource s terminate. |
Completable |
Observable.concatMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
CompletableSource s and subscribes to them one after the
other terminates, optionally delaying all errors till both this Observable and all
inner CompletableSource s terminate. |
<R> Observable<R> |
Observable.concatMapDelayError(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Maps each of the items into an ObservableSource, 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 ObservableSources
till all of them terminate.
|
<R> Observable<R> |
Observable.concatMapDelayError(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int prefetch,
boolean tillTheEnd)
Maps each of the items into an ObservableSource, 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 ObservableSources
till all of them terminate.
|
<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> Observable<R> |
Observable.concatMapEager(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single
ObservableSource.
|
<R> Observable<R> |
Observable.concatMapEager(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int maxConcurrency,
int prefetch)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single
ObservableSource.
|
<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> Observable<R> |
Observable.concatMapEagerDelayError(Function<? super T,? extends ObservableSource<? extends R>> mapper,
boolean tillTheEnd)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single
ObservableSource.
|
<R> Observable<R> |
Observable.concatMapEagerDelayError(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int maxConcurrency,
int prefetch,
boolean tillTheEnd)
Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single
ObservableSource.
|
<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> Observable<U> |
Observable.concatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns an Observable that concatenate each item emitted by the source ObservableSource 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.
|
<U> Observable<U> |
Observable.concatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper,
int prefetch)
Returns an Observable that concatenate each item emitted by the source ObservableSource 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> Observable<R> |
Observable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Observable or the current inner MaybeSource fail. |
<R> Flowable<R> |
Flowable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Flowable or the current inner MaybeSource fail. |
<R> Observable<R> |
Observable.concatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other succeeds or completes, emits their success value if available or terminates immediately if
either this Observable or the current inner MaybeSource fail. |
<R> Flowable<R> |
Flowable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and delaying all errors
till both this Flowable and all inner MaybeSource s terminate. |
<R> Observable<R> |
Observable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and delaying all errors
till both this Observable and all inner MaybeSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Flowable and all inner MaybeSource s terminate. |
<R> Observable<R> |
Observable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Observable and all inner MaybeSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Flowable and all inner MaybeSource s terminate. |
<R> Observable<R> |
Observable.concatMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
MaybeSource s and subscribes to them one after the
other terminates, emits their success value if available and optionally delaying all errors
till both this Observable and all inner MaybeSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Flowable or the current inner SingleSource fail. |
<R> Observable<R> |
Observable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Observable or the current inner SingleSource fail. |
<R> Flowable<R> |
Flowable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Flowable or the current inner SingleSource fail. |
<R> Observable<R> |
Observable.concatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds, emits their success values or terminates immediately if
either this Observable or the current inner SingleSource fail. |
<R> Flowable<R> |
Flowable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and delays all errors
till both this Flowable and all inner SingleSource s terminate. |
<R> Observable<R> |
Observable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and delays all errors
till both this Observable and all inner SingleSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays all errors
till both this Flowable and all inner SingleSource s terminate. |
<R> Observable<R> |
Observable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays all errors
till both this Observable and all inner SingleSource s terminate. |
<R> Flowable<R> |
Flowable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays errors
till both this Flowable and all inner SingleSource s terminate. |
<R> Observable<R> |
Observable.concatMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean tillTheEnd,
int prefetch)
Maps the upstream items into
SingleSource s and subscribes to them one after the
other succeeds or fails, emits their success values and optionally delays errors
till both this Observable and all inner SingleSource s terminate. |
Completable |
Completable.concatWith(CompletableSource other)
Concatenates this Completable with another Completable.
|
Flowable<T> |
Flowable.concatWith(CompletableSource other)
Returns a
Flowable that emits items from this Flowable and when it completes normally, the
other CompletableSource is subscribed to and the returned Flowable emits its terminal events. |
Observable<T> |
Observable.concatWith(CompletableSource other)
Returns an
Observable that emits items from this Observable and when it completes normally, the
other CompletableSource is subscribed to and the returned Observable emits its terminal events. |
Flowable<T> |
Maybe.concatWith(MaybeSource<? extends T> other)
Returns a Flowable that emits the items emitted from the current MaybeSource, then the next, one after
the other, without interleaving them.
|
Flowable<T> |
Flowable.concatWith(MaybeSource<? extends T> other)
Returns a
Flowable that emits the items from this Flowable followed by the success item or terminal events
of the other MaybeSource . |
Observable<T> |
Observable.concatWith(MaybeSource<? extends T> other)
Returns an
Observable that emits the items from this Observable followed by the success item or terminal events
of the other MaybeSource . |
Observable<T> |
Observable.concatWith(ObservableSource<? extends T> other)
Returns an Observable that emits the items emitted from the current ObservableSource, then the next, one after
the other, without interleaving them.
|
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> |
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 . |
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.
|
Observable<T> |
Observable.concatWith(SingleSource<? extends T> other)
Returns an
Observable that emits the items from this Observable followed by the success item or error event
of the other SingleSource . |
Single<Boolean> |
Maybe.contains(Object item)
Returns a Single that emits a Boolean that indicates whether the source Maybe emitted a
specified item.
|
Single<Boolean> |
Flowable.contains(Object item)
Returns a Single that emits a Boolean that indicates whether the source Publisher emitted a
specified item.
|
Single<Boolean> |
Single.contains(Object value)
Signals true if the current Single signals a success value that is Object-equals with the value
provided.
|
Single<Boolean> |
Observable.contains(Object element)
Returns a Single that emits a Boolean that indicates whether the source ObservableSource emitted a
specified item.
|
Single<Boolean> |
Single.contains(Object value,
BiPredicate<Object,Object> comparer)
Signals true if the current Single signals a success value that is equal with
the value provided by calling a bi-predicate.
|
Single<Long> |
Maybe.count()
Returns a Maybe that counts the total number of items emitted (0 or 1) by the source Maybe and emits
this count as a 64-bit Long.
|
Single<Long> |
Flowable.count()
Returns a Single that counts the total number of items emitted by the source Publisher and emits
this count as a 64-bit Long.
|
Single<Long> |
Observable.count()
Returns a Single that counts the total number of items emitted by the source ObservableSource and emits
this count as a 64-bit Long.
|
static Completable |
Completable.create(CompletableOnSubscribe source)
Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
|
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.
|
static <T> Maybe<T> |
Maybe.create(MaybeOnSubscribe<T> onSubscribe)
Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.
|
static <T> Observable<T> |
Observable.create(ObservableOnSubscribe<T> source)
Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.
|
static <T> Single<T> |
Single.create(SingleOnSubscribe<T> source)
Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
|
<U> Observable<T> |
Observable.debounce(Function<? super T,? extends ObservableSource<U>> debounceSelector)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the
source ObservableSource that are followed by another item within a computed debounce duration.
|
<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.
|
Observable<T> |
Observable.debounce(long timeout,
TimeUnit unit)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the
source ObservableSource 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.
|
Observable<T> |
Observable.debounce(long timeout,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the
source ObservableSource that are followed by newer items before a timeout value expires on a specified
Scheduler.
|
Maybe<T> |
Maybe.defaultIfEmpty(T defaultItem)
Returns a Maybe that emits the item emitted by the source Maybe or a specified default item
if the source Maybe is empty.
|
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.
|
Observable<T> |
Observable.defaultIfEmpty(T defaultItem)
Returns an Observable that emits the items emitted by the source ObservableSource or a specified default item
if the source ObservableSource is empty.
|
static Completable |
Completable.defer(Callable<? extends CompletableSource> completableSupplier)
Defers the subscription to a Completable instance returned by a supplier.
|
static <T> Maybe<T> |
Maybe.defer(Callable<? extends MaybeSource<? extends T>> maybeSupplier)
Calls a Callable for each individual MaybeObserver to return the actual MaybeSource source to
be subscribed to.
|
static <T> Observable<T> |
Observable.defer(Callable<? extends ObservableSource<? extends T>> supplier)
Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer
that subscribes.
|
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.
|
static <T> Single<T> |
Single.defer(Callable<? extends SingleSource<? extends T>> singleSupplier)
Calls a
Callable for each individual SingleObserver to return the actual SingleSource to
be subscribed to. |
<U> Observable<T> |
Observable.delay(Function<? super T,? extends ObservableSource<U>> itemDelay)
Returns an Observable that delays the emissions of the source ObservableSource via another ObservableSource on a
per-item basis.
|
<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.
|
Completable |
Completable.delay(long delay,
TimeUnit unit)
Returns a Completable which delays the emission of the completion event by the given time.
|
Maybe<T> |
Maybe.delay(long delay,
TimeUnit unit)
Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a
specified delay.
|
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.
|
Single<T> |
Single.delay(long time,
TimeUnit unit)
Delays the emission of the success signal from the current Single by the specified amount.
|
Observable<T> |
Observable.delay(long delay,
TimeUnit unit)
Returns an Observable that emits the items emitted by the source ObservableSource 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.
|
Single<T> |
Single.delay(long time,
TimeUnit unit,
boolean delayError)
Delays the emission of the success or error signal from the current Single by the specified amount.
|
Observable<T> |
Observable.delay(long delay,
TimeUnit unit,
boolean delayError)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a
specified delay.
|
Completable |
Completable.delay(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Completable which delays the emission of the completion event by the given time while
running on the specified scheduler.
|
Maybe<T> |
Maybe.delay(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Maybe that signals the events emitted by the source Maybe shifted forward in time by a
specified delay running on the specified Scheduler.
|
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.
|
Single<T> |
Single.delay(long time,
TimeUnit unit,
Scheduler scheduler)
Delays the emission of the success signal from the current Single by the specified amount.
|
Observable<T> |
Observable.delay(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a
specified delay.
|
Completable |
Completable.delay(long delay,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while
running on the specified scheduler.
|
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.
|
Single<T> |
Single.delay(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Delays the emission of the success or error signal from the current Single by the specified amount.
|
Observable<T> |
Observable.delay(long delay,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns an Observable that emits the items emitted by the source ObservableSource shifted forward in time by a
specified delay.
|
<U,V> Observable<T> |
Observable.delay(ObservableSource<U> subscriptionDelay,
Function<? super T,? extends ObservableSource<V>> itemDelay)
Returns an Observable that delays the subscription to and emissions from the source ObservableSource via another
ObservableSource on a per-item basis.
|
<U,V> Maybe<T> |
Maybe.delay(org.reactivestreams.Publisher<U> delayIndicator)
Delays the emission of this Maybe until the given Publisher signals an item or completes.
|
<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.
|
Single<T> |
Single.delaySubscription(CompletableSource other)
Delays the actual subscription to the current Single until the given other CompletableSource
completes.
|
Maybe<T> |
Maybe.delaySubscription(long delay,
TimeUnit unit)
Returns a Maybe that delays the subscription to the source Maybe by a given amount of time.
|
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.
|
Single<T> |
Single.delaySubscription(long time,
TimeUnit unit)
Delays the actual subscription to the current Single until the given time delay elapsed.
|
Observable<T> |
Observable.delaySubscription(long delay,
TimeUnit unit)
Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time.
|
Maybe<T> |
Maybe.delaySubscription(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Maybe that delays the subscription to the source Maybe by a given amount of time,
both waiting and subscribing on a given Scheduler.
|
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.
|
Single<T> |
Single.delaySubscription(long time,
TimeUnit unit,
Scheduler scheduler)
Delays the actual subscription to the current Single until the given time delay elapsed.
|
Observable<T> |
Observable.delaySubscription(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that delays the subscription to the source ObservableSource by a given amount of time,
both waiting and subscribing on a given Scheduler.
|
<U> Single<T> |
Single.delaySubscription(ObservableSource<U> other)
Delays the actual subscription to the current Single until the given other ObservableSource
signals its first value or completes.
|
<U> Observable<T> |
Observable.delaySubscription(ObservableSource<U> other)
Returns an Observable that delays the subscription to this Observable
until the other Observable emits an element or completes normally.
|
<U> Maybe<T> |
Maybe.delaySubscription(org.reactivestreams.Publisher<U> subscriptionIndicator)
Returns a Maybe that delays the subscription to this Maybe
until the other Publisher emits an element or completes normally.
|
<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.
|
<U> Single<T> |
Single.delaySubscription(org.reactivestreams.Publisher<U> other)
Delays the actual subscription to the current Single until the given other Publisher
signals its first value or completes.
|
<U> Single<T> |
Single.delaySubscription(SingleSource<U> other)
Delays the actual subscription to the current Single until the given other SingleSource
signals success.
|
<T2> Flowable<T2> |
Flowable.dematerialize()
Returns a Flowable that reverses the effect of
materialize by transforming the
Notification objects emitted by the source Publisher into the items or notifications they
represent. |
<T2> Observable<T2> |
Observable.dematerialize()
Returns an Observable that reverses the effect of
materialize by transforming the
Notification objects emitted by the source ObservableSource into the items or notifications they
represent. |
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. |
Observable<T> |
Observable.distinct()
Returns an Observable that emits all items emitted by the source ObservableSource 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> Observable<T> |
Observable.distinct(Function<? super T,K> keySelector)
Returns an Observable that emits all items emitted by the source ObservableSource 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. |
<K> Observable<T> |
Observable.distinct(Function<? super T,K> keySelector,
Callable<? extends Collection<? super K>> collectionSupplier)
Returns an Observable that emits all items emitted by the source ObservableSource 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. |
Observable<T> |
Observable.distinctUntilChanged()
Returns an Observable that emits all items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.distinctUntilChanged(BiPredicate<? super T,? super T> comparer)
Returns an Observable that emits all items emitted by the source ObservableSource 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. |
<K> Observable<T> |
Observable.distinctUntilChanged(Function<? super T,K> keySelector)
Returns an Observable that emits all items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.doAfterNext(Consumer<? super T> onAfterNext)
Calls the specified consumer with the current item after this item has been emitted to the downstream.
|
Maybe<T> |
Maybe.doAfterSuccess(Consumer<? super T> onAfterSuccess)
Calls the specified consumer with the success item after this item has been emitted to the downstream.
|
Single<T> |
Single.doAfterSuccess(Consumer<? super T> onAfterSuccess)
Calls the specified consumer with the success item after this item has been emitted to the downstream.
|
Completable |
Completable.doAfterTerminate(Action onAfterTerminate)
Returns a Completable instance that calls the given onTerminate callback after this Completable
completes normally or with an exception.
|
Maybe<T> |
Maybe.doAfterTerminate(Action onAfterTerminate)
|
Flowable<T> |
Flowable.doAfterTerminate(Action onAfterTerminate)
|
Single<T> |
Single.doAfterTerminate(Action onAfterTerminate)
Registers an
Action to be called after this Single invokes either onSuccess or onError. |
Observable<T> |
Observable.doAfterTerminate(Action onFinally)
|
Completable |
Completable.doFinally(Action onFinally)
Calls the specified action after this Completable signals onError or onComplete or gets disposed by
the downstream.
|
Maybe<T> |
Maybe.doFinally(Action onFinally)
Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by
the downstream.
|
Flowable<T> |
Flowable.doFinally(Action onFinally)
Calls the specified action after this Flowable signals onError or onCompleted or gets canceled by
the downstream.
|
Single<T> |
Single.doFinally(Action onFinally)
Calls the specified action after this Single signals onSuccess or onError or gets disposed by
the downstream.
|
Observable<T> |
Observable.doFinally(Action onFinally)
Calls the specified action after this Observable signals onError or onCompleted or gets disposed by
the downstream.
|
Flowable<T> |
Flowable.doOnCancel(Action onCancel)
Calls the cancel
Action if the downstream cancels the sequence. |
Completable |
Completable.doOnComplete(Action onComplete)
Returns a Completable which calls the given onComplete callback if this Completable completes.
|
Maybe<T> |
Maybe.doOnComplete(Action onComplete)
Modifies the source Maybe so that it invokes an action when it calls
onComplete . |
Flowable<T> |
Flowable.doOnComplete(Action onComplete)
Modifies the source Publisher so that it invokes an action when it calls
onComplete . |
Observable<T> |
Observable.doOnComplete(Action onComplete)
Modifies the source ObservableSource so that it invokes an action when it calls
onComplete . |
Completable |
Completable.doOnDispose(Action onDispose)
Calls the shared
Action if a CompletableObserver subscribed to the current
Completable disposes the common Disposable it received via onSubscribe. |
Maybe<T> |
Maybe.doOnDispose(Action onDispose)
Calls the shared
Action if a MaybeObserver subscribed to the current Maybe
disposes the common Disposable it received via onSubscribe. |
Single<T> |
Single.doOnDispose(Action onDispose)
Calls the shared
Action if a SingleObserver subscribed to the current Single
disposes the common Disposable it received via onSubscribe. |
Observable<T> |
Observable.doOnDispose(Action onDispose)
Calls the dispose
Action if the downstream disposes the sequence. |
Flowable<T> |
Flowable.doOnEach(Consumer<? super Notification<T>> onNotification)
Modifies the source Publisher so that it invokes an action for each item it emits.
|
Observable<T> |
Observable.doOnEach(Consumer<? super Notification<T>> onNotification)
Modifies the source ObservableSource so that it invokes an action for each item it emits.
|
Observable<T> |
Observable.doOnEach(Observer<? super T> observer)
Modifies the source ObservableSource so that it notifies an Observer for each item and terminal event 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.
|
Completable |
Completable.doOnError(Consumer<? super Throwable> onError)
Returns a Completable which calls the given onError callback if this Completable emits an error.
|
Maybe<T> |
Maybe.doOnError(Consumer<? super Throwable> onError)
Calls the shared consumer with the error sent via onError for each
MaybeObserver that subscribes to the current Maybe.
|
Flowable<T> |
Flowable.doOnError(Consumer<? super Throwable> onError)
Modifies the source Publisher so that it invokes an action if it calls
onError . |
Single<T> |
Single.doOnError(Consumer<? super Throwable> onError)
Calls the shared consumer with the error sent via onError for each
SingleObserver that subscribes to the current Single.
|
Observable<T> |
Observable.doOnError(Consumer<? super Throwable> onError)
Modifies the source ObservableSource so that it invokes an action if it calls
onError . |
Maybe<T> |
Maybe.doOnEvent(BiConsumer<? super T,? super Throwable> onEvent)
Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for
an onError or (null, null) for an onComplete signal from this Maybe before delivering said
signal to the downstream.
|
Single<T> |
Single.doOnEvent(BiConsumer<? super T,? super Throwable> onEvent)
Calls the shared consumer with the error sent via onError or the value
via onSuccess for each SingleObserver that subscribes to the current Single.
|
Completable |
Completable.doOnEvent(Consumer<? super Throwable> onEvent)
Returns a Completable which calls the given onEvent callback with the (throwable) for an onError
or (null) for an onComplete signal from this Completable before delivering said signal to the downstream.
|
Observable<T> |
Observable.doOnLifecycle(Consumer<? super Disposable> onSubscribe,
Action onDispose)
Calls the appropriate onXXX method (shared between all Observer) for the lifecycle events of
the sequence (subscription, cancellation, requesting).
|
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 . |
Observable<T> |
Observable.doOnNext(Consumer<? super T> onNext)
Modifies the source ObservableSource 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. |
Completable |
Completable.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Returns a Completable instance that calls the given onSubscribe callback with the disposable
that child subscribers receive on subscription.
|
Maybe<T> |
Maybe.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Calls the shared consumer with the Disposable sent through the onSubscribe for each
MaybeObserver that subscribes to the current Maybe.
|
Single<T> |
Single.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Calls the shared consumer with the Disposable sent through the onSubscribe for each
SingleObserver that subscribes to the current Single.
|
Observable<T> |
Observable.doOnSubscribe(Consumer<? super Disposable> onSubscribe)
Modifies the source
ObservableSource so that it invokes the given action when it is subscribed from
its subscribers. |
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. |
Maybe<T> |
Maybe.doOnSuccess(Consumer<? super T> onSuccess)
Calls the shared consumer with the success value sent via onSuccess for each
MaybeObserver that subscribes to the current Maybe.
|
Single<T> |
Single.doOnSuccess(Consumer<? super T> onSuccess)
Calls the shared consumer with the success value sent via onSuccess for each
SingleObserver that subscribes to the current Single.
|
Completable |
Completable.doOnTerminate(Action onTerminate)
Returns a Completable instance that calls the given onTerminate callback just before this Completable
completes normally or with an exception.
|
Flowable<T> |
Flowable.doOnTerminate(Action onTerminate)
Modifies the source Publisher so that it invokes an action when it calls
onComplete or
onError . |
Observable<T> |
Observable.doOnTerminate(Action onTerminate)
Modifies the source ObservableSource so that it invokes an action when it calls
onComplete or
onError . |
Maybe<T> |
Flowable.elementAt(long index)
Returns a Maybe that emits the single item at a specified index in a sequence of emissions from
this Flowable or completes if this Flowable sequence has fewer elements than index.
|
Maybe<T> |
Observable.elementAt(long index)
Returns a Maybe that emits the single item at a specified index in a sequence of emissions from
this Observable or completes if this Observable signals fewer elements than index.
|
Single<T> |
Flowable.elementAt(long index,
T defaultItem)
Returns a Flowable that emits the item found at a specified index in a sequence of emissions from
this Flowable, or a default item if that index is out of range.
|
Single<T> |
Observable.elementAt(long index,
T defaultItem)
Returns a Single that emits the item found at a specified index in a sequence of emissions from
this Observable, or a default item if that index is out of range.
|
Single<T> |
Flowable.elementAtOrError(long index)
Returns a Flowable that emits the item found at a specified index in a sequence of emissions from
this Flowable or signals a
NoSuchElementException if this Flowable has fewer elements than index. |
Single<T> |
Observable.elementAtOrError(long index)
Returns a Single that emits the item found at a specified index in a sequence of emissions from this Observable
or signals a
NoSuchElementException if this Observable signals fewer elements than index. |
static <T> Maybe<T> |
Maybe.empty()
Returns a (singleton) Maybe instance that calls
onComplete
immediately. |
static <T> Flowable<T> |
Flowable.empty()
Returns a Flowable that emits no items to the
Subscriber and immediately invokes its
onComplete method. |
static <T> Observable<T> |
Observable.empty()
Returns an Observable that emits no items to the
Observer and immediately invokes its
onComplete method. |
static <T> Single<Boolean> |
Single.equals(SingleSource<? extends T> first,
SingleSource<? extends T> second)
Compares two SingleSources and emits true if they emit the same value (compared via Object.equals).
|
static Completable |
Completable.error(Callable<? extends Throwable> errorSupplier)
Creates a Completable which calls the given error supplier for each subscriber
and emits its returned Throwable.
|
static <T> Maybe<T> |
Maybe.error(Callable<? extends Throwable> supplier)
Returns a Maybe that invokes a
MaybeObserver 's onError method when the
MaybeObserver subscribes to it. |
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> Single<T> |
Single.error(Callable<? extends Throwable> errorSupplier)
Signals a Throwable returned by the callback function for each individual SingleObserver.
|
static <T> Observable<T> |
Observable.error(Callable<? extends Throwable> errorSupplier)
|
static Completable |
Completable.error(Throwable error)
Creates a Completable instance that emits the given Throwable exception to subscribers.
|
static <T> Maybe<T> |
Maybe.error(Throwable exception)
Returns a Maybe 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. |
static <T> Single<T> |
Single.error(Throwable exception)
Returns a Single that invokes a subscriber's
onError method when the
subscriber subscribes to it. |
static <T> Observable<T> |
Observable.error(Throwable exception)
|
Maybe<T> |
Maybe.filter(Predicate<? super T> predicate)
Filters the success item of the Maybe via a predicate function and emitting it if the predicate
returns true, completing otherwise.
|
Flowable<T> |
Flowable.filter(Predicate<? super T> predicate)
Filters items emitted by a Publisher by only emitting those that satisfy a specified predicate.
|
Maybe<T> |
Single.filter(Predicate<? super T> predicate)
Filters the success item of the Single via a predicate function and emitting it if the predicate
returns true, completing otherwise.
|
Observable<T> |
Observable.filter(Predicate<? super T> predicate)
Filters items emitted by an ObservableSource by only emitting those that satisfy a specified predicate.
|
Single<T> |
Flowable.first(T defaultItem)
Returns a Single that emits only the very first item emitted by this Flowable, or a default
item if this Flowable completes without emitting anything.
|
Single<T> |
Observable.first(T defaultItem)
Returns a Single that emits only the very first item emitted by the source ObservableSource, or a default item
if the source ObservableSource completes without emitting any items.
|
Maybe<T> |
Flowable.firstElement()
Returns a Maybe that emits only the very first item emitted by this Flowable or
completes if this Flowable is empty.
|
Maybe<T> |
Observable.firstElement()
Returns a Maybe that emits only the very first item emitted by the source ObservableSource, or
completes if the source ObservableSource is empty.
|
Single<T> |
Flowable.firstOrError()
Returns a Single that emits only the very first item emitted by this Flowable or
signals a
NoSuchElementException if this Flowable is empty. |
Single<T> |
Observable.firstOrError()
Returns a Single that emits only the very first item emitted by this Observable or
signals a
NoSuchElementException if this Observable is empty. |
<R> Maybe<R> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Returns a Maybe that is based on applying a specified function to the item emitted by the source Maybe,
where that function returns a MaybeSource.
|
<R> Maybe<R> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends R>> onSuccessMapper,
Function<? super Throwable,? extends MaybeSource<? extends R>> onErrorMapper,
Callable<? extends MaybeSource<? extends R>> onCompleteSupplier)
Maps the onSuccess, onError or onComplete signals of this Maybe into MaybeSource and emits that
MaybeSource's signals.
|
<U,R> Maybe<R> |
Maybe.flatMap(Function<? super T,? extends MaybeSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> resultSelector)
Returns a Maybe that emits the results of a specified function to the pair of values emitted by the
source Maybe and a specified mapped MaybeSource.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting
ObservableSources and emitting the results of this merger.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper,
boolean delayErrors)
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting
ObservableSources and emitting the results of this merger.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency)
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting
ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency,
int bufferSize)
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting
ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
Function<? super Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
Callable<? extends ObservableSource<? extends R>> onCompleteSupplier)
Returns an Observable that applies a function to each item emitted or notification raised by the source
ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
Function<Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
Callable<? extends ObservableSource<? extends R>> onCompleteSupplier,
int maxConcurrency)
Returns an Observable that applies a function to each item emitted or notification raised by the source
ObservableSource and then flattens the ObservableSources returned from these functions and emits the resulting items,
while limiting the maximum number of concurrent subscriptions to these ObservableSources.
|
<R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int maxConcurrency)
Returns an Observable that emits items based on applying a function that you supply to each item emitted
by the source ObservableSource, where that function returns an ObservableSource, and then merging those resulting
ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
<U,R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> resultSelector)
Returns an Observable that emits the results of a specified function to the pair of values emitted by the
source ObservableSource and a specified collection ObservableSource.
|
<U,R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
boolean delayErrors)
Returns an Observable that emits the results of a specified function to the pair of values emitted by the
source ObservableSource and a specified collection ObservableSource.
|
<U,R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
boolean delayErrors,
int maxConcurrency)
Returns an Observable that emits the results of a specified function to the pair of values emitted by the
source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
<U,R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
boolean delayErrors,
int maxConcurrency,
int bufferSize)
Returns an Observable that emits the results of a specified function to the pair of values emitted by the
source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
<U,R> Observable<R> |
Observable.flatMap(Function<? super T,? extends ObservableSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> combiner,
int maxConcurrency)
Returns an Observable that emits the results of a specified function to the pair of values emitted by the
source ObservableSource and a specified collection ObservableSource, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
<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.
|
<R> Single<R> |
Single.flatMap(Function<? super T,? extends SingleSource<? extends R>> mapper)
Returns a Single that is based on applying a specified function to the item emitted by the source Single,
where that function returns a SingleSource.
|
Completable |
Maybe.flatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Returns a
Completable that completes based on applying a specified function to the item emitted by the
source Maybe , where that function returns a Completable . |
Completable |
Flowable.flatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps each element of the upstream Flowable into CompletableSources, subscribes to them and
waits until the upstream and all CompletableSources complete.
|
Completable |
Single.flatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Returns a
Completable that completes based on applying a specified function to the item emitted by the
source Single , where that function returns a Completable . |
Completable |
Observable.flatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps each element of the upstream Observable into CompletableSources, subscribes to them and
waits until the upstream and all CompletableSources complete.
|
Completable |
Observable.flatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
boolean delayErrors)
Maps each element of the upstream Observable into CompletableSources, subscribes to them and
waits until the upstream and all CompletableSources complete, optionally delaying all errors.
|
Completable |
Flowable.flatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
boolean delayErrors,
int maxConcurrency)
Maps each element of the upstream Flowable into CompletableSources, subscribes to them and
waits until the upstream and all CompletableSources complete, optionally delaying all errors.
|
<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> Observable<U> |
Observable.flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns an Observable that merges each item emitted by the source ObservableSource 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> Observable<V> |
Observable.flatMapIterable(Function<? super T,? extends Iterable<? extends U>> mapper,
BiFunction<? super T,? super U,? extends V> resultSelector)
Returns an Observable that emits the results of applying a function to the pair of values from the source
ObservableSource 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> Maybe<R> |
Single.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Returns a Maybe that is based on applying a specified function to the item emitted by the source Single,
where that function returns a MaybeSource.
|
<R> Observable<R> |
Observable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps each element of the upstream Observable into MaybeSources, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Observable sequence.
|
<R> Observable<R> |
Observable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors)
Maps each element of the upstream Observable into MaybeSources, subscribes to them
and merges their onSuccess values, in no particular order, into a single Observable sequence,
optionally delaying all errors.
|
<R> Flowable<R> |
Flowable.flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors,
int maxConcurrency)
Maps each element of the upstream Flowable into MaybeSources, subscribes to at most
maxConcurrency MaybeSources at a time and merges their onSuccess values,
in no particular order, into a single Flowable sequence, optionally delaying all errors. |
<R> Observable<R> |
Maybe.flatMapObservable(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns an Observable that is based on applying a specified function to the item emitted by the source Maybe,
where that function returns an ObservableSource.
|
<R> Observable<R> |
Single.flatMapObservable(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns an Observable that is based on applying a specified function to the item emitted by the source Single,
where that function returns an ObservableSource.
|
<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> |
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> Single<R> |
Maybe.flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
|
<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> Observable<R> |
Observable.flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps each element of the upstream Observable into SingleSources, subscribes to all of them
and merges their onSuccess values, in no particular order, into a single Observable sequence.
|
<R> Observable<R> |
Observable.flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean delayErrors)
Maps each element of the upstream Observable into SingleSources, subscribes to them
and merges their onSuccess values, in no particular order, into a single Observable sequence,
optionally delaying all errors.
|
<R> Flowable<R> |
Flowable.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. |
<R> Maybe<R> |
Maybe.flatMapSingleElement(Function<? super T,? extends SingleSource<? extends R>> mapper)
|
<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.
|
<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> Observable<U> |
Maybe.flattenAsObservable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns an Observable that maps a success value into an Iterable and emits its items.
|
<U> Observable<U> |
Single.flattenAsObservable(Function<? super T,? extends Iterable<? extends U>> mapper)
Returns an Observable that maps a success value into an Iterable and emits its items.
|
Disposable |
Flowable.forEach(Consumer<? super T> onNext)
Subscribes to the
Publisher and receives notifications for each element. |
Disposable |
Observable.forEach(Consumer<? super T> onNext)
Subscribes to the
ObservableSource and receives notifications for each element. |
Disposable |
Flowable.forEachWhile(Predicate<? super T> onNext)
Subscribes to the
Publisher and receives notifications for each element until the
onNext Predicate returns false. |
Disposable |
Observable.forEachWhile(Predicate<? super T> onNext)
Subscribes to the
ObservableSource and receives notifications for each element until the
onNext Predicate returns false. |
Disposable |
Flowable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to the
Publisher and receives notifications for each element and error events until the
onNext Predicate returns false. |
Disposable |
Observable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to the
ObservableSource and receives notifications for each element and error events until the
onNext Predicate returns false. |
Disposable |
Flowable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to the
Publisher and receives notifications for each element and the terminal events until the
onNext Predicate returns false. |
Disposable |
Observable.forEachWhile(Predicate<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to the
ObservableSource and receives notifications for each element and the terminal events until the
onNext Predicate returns false. |
static Completable |
Completable.fromAction(Action run)
Returns a Completable instance that runs the given Action for each subscriber and
emits either an unchecked exception or simply completes.
|
static <T> Maybe<T> |
Maybe.fromAction(Action run)
Returns a Maybe instance that runs the given Action for each subscriber and
emits either its exception or simply completes.
|
static <T> Flowable<T> |
Flowable.fromArray(T... items)
Converts an Array into a Publisher that emits the items in the Array.
|
static <T> Observable<T> |
Observable.fromArray(T... items)
Converts an Array into an ObservableSource that emits the items in the Array.
|
static Completable |
Completable.fromCallable(Callable<?> callable)
Returns a Completable which when subscribed, executes the callable function, ignores its
normal result and emits onError or onComplete only.
|
static <T> Maybe<T> |
Maybe.fromCallable(Callable<? extends T> callable)
Returns a
Maybe that invokes the given Callable for each individual MaybeObserver that
subscribes and emits the resulting non-null item via onSuccess while
considering a null result from the Callable as indication for valueless completion
via onComplete . |
static <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> Single<T> |
Single.fromCallable(Callable<? extends T> callable)
Returns a
Single that invokes passed function and emits its result for each new SingleObserver that subscribes. |
static <T> Observable<T> |
Observable.fromCallable(Callable<? extends T> supplier)
Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then
emits the value returned from that function.
|
static <T> Maybe<T> |
Maybe.fromCompletable(CompletableSource completableSource)
Wraps a CompletableSource into a Maybe.
|
static Completable |
Completable.fromFuture(Future<?> future)
Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
|
static <T> Maybe<T> |
Maybe.fromFuture(Future<? extends T> future)
Converts a
Future into a Maybe, treating a null result as an indication of emptiness. |
static <T> Flowable<T> |
Flowable.fromFuture(Future<? extends T> future)
Converts a
Future into a Publisher. |
static <T> Single<T> |
Single.fromFuture(Future<? extends T> future)
Converts a
Future into a Single . |
static <T> Observable<T> |
Observable.fromFuture(Future<? extends T> future)
Converts a
Future into an ObservableSource. |
static <T> Maybe<T> |
Maybe.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit)
Converts a
Future into a Maybe, with a timeout on the Future. |
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> Single<T> |
Single.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit)
Converts a
Future into a Single , with a timeout on the Future. |
static <T> Observable<T> |
Observable.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit)
Converts a
Future into an ObservableSource, 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> Single<T> |
Single.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit,
Scheduler scheduler)
Converts a
Future into a Single , with a timeout on the Future. |
static <T> Observable<T> |
Observable.fromFuture(Future<? extends T> future,
long timeout,
TimeUnit unit,
Scheduler scheduler)
Converts a
Future into an ObservableSource, with a timeout on the Future. |
static <T> Flowable<T> |
Flowable.fromFuture(Future<? extends T> future,
Scheduler scheduler)
|
static <T> Single<T> |
Single.fromFuture(Future<? extends T> future,
Scheduler scheduler)
|
static <T> Observable<T> |
Observable.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> Observable<T> |
Observable.fromIterable(Iterable<? extends T> source)
Converts an
Iterable sequence into an ObservableSource that emits the items in the sequence. |
static <T> Single<T> |
Single.fromObservable(ObservableSource<? extends T> observableSource)
Wraps a specific ObservableSource into a Single and signals its single element or error.
|
static <T> Completable |
Completable.fromObservable(ObservableSource<T> observable)
Returns a Completable instance that subscribes to the given Observable, ignores all values and
emits only the terminal event.
|
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> Single<T> |
Single.fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
Wraps a specific Publisher into a Single and signals its single element or error.
|
static <T> Observable<T> |
Observable.fromPublisher(org.reactivestreams.Publisher<? extends T> publisher)
Converts an arbitrary Reactive-Streams Publisher into an Observable.
|
static <T> Completable |
Completable.fromPublisher(org.reactivestreams.Publisher<T> publisher)
Returns a Completable instance that subscribes to the given publisher, ignores all values and
emits only the terminal event.
|
static Completable |
Completable.fromRunnable(Runnable run)
Returns a Completable instance that runs the given Runnable for each subscriber and
emits either its exception or simply completes.
|
static <T> Maybe<T> |
Maybe.fromRunnable(Runnable run)
Returns a Maybe instance that runs the given Action for each subscriber and
emits either its exception or simply completes.
|
static <T> Completable |
Completable.fromSingle(SingleSource<T> single)
Returns a Completable instance that when subscribed to, subscribes to the Single instance and
emits a completion event if the single emits onSuccess or forwards any onError events.
|
static <T> Maybe<T> |
Maybe.fromSingle(SingleSource<T> singleSource)
Wraps a SingleSource into a Maybe.
|
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> Observable<T> |
Observable.generate(Callable<S> initialState,
BiConsumer<S,Emitter<T>> generator)
Returns a cold, synchronous and stateful 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> Observable<T> |
Observable.generate(Callable<S> initialState,
BiConsumer<S,Emitter<T>> generator,
Consumer<? super S> disposeState)
Returns a cold, synchronous and stateful 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> Observable<T> |
Observable.generate(Callable<S> initialState,
BiFunction<S,Emitter<T>,S> generator)
Returns a cold, synchronous and stateful 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,S> Observable<T> |
Observable.generate(Callable<S> initialState,
BiFunction<S,Emitter<T>,S> generator,
Consumer<? super S> disposeState)
Returns a cold, synchronous and stateful generator of values.
|
static <T> Flowable<T> |
Flowable.generate(Consumer<Emitter<T>> generator)
Returns a cold, synchronous, stateless and backpressure-aware generator of values.
|
static <T> Observable<T> |
Observable.generate(Consumer<Emitter<T>> generator)
Returns a cold, synchronous and stateless 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> Observable<GroupedObservable<K,T>> |
Observable.groupBy(Function<? super T,? extends K> keySelector)
Groups the items emitted by an
ObservableSource according to a specified criterion, and emits these
grouped items as GroupedObservable 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> Observable<GroupedObservable<K,T>> |
Observable.groupBy(Function<? super T,? extends K> keySelector,
boolean delayError)
Groups the items emitted by an
ObservableSource according to a specified criterion, and emits these
grouped items as GroupedObservable 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> Observable<GroupedObservable<K,V>> |
Observable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
Groups the items emitted by an
ObservableSource according to a specified criterion, and emits these
grouped items as GroupedObservable 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> Observable<GroupedObservable<K,V>> |
Observable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
boolean delayError)
Groups the items emitted by an
ObservableSource according to a specified criterion, and emits these
grouped items as GroupedObservable 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> Observable<GroupedObservable<K,V>> |
Observable.groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
boolean delayError,
int bufferSize)
Groups the items emitted by an
ObservableSource according to a specified criterion, and emits these
grouped items as GroupedObservable 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> |
Observable.groupJoin(ObservableSource<? extends TRight> other,
Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd,
Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd,
BiFunction<? super T,? super Observable<TRight>,? extends R> resultSelector)
Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.
|
<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.
|
Completable |
Completable.hide()
Hides the identity of this Completable and its Disposable.
|
Maybe<T> |
Maybe.hide()
Hides the identity of this Maybe and its Disposable.
|
Flowable<T> |
Flowable.hide()
Hides the identity of this Flowable and its Subscription.
|
Single<T> |
Single.hide()
Hides the identity of the current Single, including the Disposable that is sent
to the downstream via
onSubscribe() . |
Observable<T> |
Observable.hide()
Hides the identity of this Observable and its Disposable.
|
Completable |
Maybe.ignoreElement()
Ignores the item emitted by the source Maybe and only calls
onComplete or onError . |
Completable |
Single.ignoreElement()
Returns a
Completable that ignores the success value of this Single
and calls onComplete instead on the returned Completable . |
Completable |
Flowable.ignoreElements()
Ignores all items emitted by the source Publisher and only calls
onComplete or onError . |
Completable |
Observable.ignoreElements()
Ignores all items emitted by the source ObservableSource and only calls
onComplete or onError . |
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 Observable<Long> |
Observable.interval(long initialDelay,
long period,
TimeUnit unit)
Returns an Observable 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 Observable<Long> |
Observable.interval(long initialDelay,
long period,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable 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 Observable<Long> |
Observable.interval(long period,
TimeUnit unit)
Returns an Observable 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 Observable<Long> |
Observable.interval(long period,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable 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 Observable<Long> |
Observable.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.
|
static Observable<Long> |
Observable.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.
|
Single<Boolean> |
Maybe.isEmpty()
Returns a Single that emits
true if the source Maybe is empty, otherwise false . |
Single<Boolean> |
Flowable.isEmpty()
Returns a Single that emits
true if the source Publisher is empty, otherwise false . |
Single<Boolean> |
Observable.isEmpty()
Returns a Single that emits
true if the source ObservableSource is empty, otherwise false . |
<TRight,TLeftEnd,TRightEnd,R> |
Observable.join(ObservableSource<? extends TRight> other,
Function<? super T,? extends ObservableSource<TLeftEnd>> leftEnd,
Function<? super TRight,? extends ObservableSource<TRightEnd>> rightEnd,
BiFunction<? super T,? super TRight,? extends R> resultSelector)
Correlates the items emitted by two ObservableSources based on overlapping durations.
|
<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> Maybe<T> |
Maybe.just(T item)
Returns a
Maybe that emits a specified item. |
static <T> Flowable<T> |
Flowable.just(T item)
Returns a Flowable that signals the given (constant reference) item and then completes.
|
static <T> Single<T> |
Single.just(T item)
Returns a
Single that emits a specified item. |
static <T> Observable<T> |
Observable.just(T item)
Returns an Observable 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> Observable<T> |
Observable.just(T item1,
T item2)
Converts two items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3)
Converts three items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3,
T item4)
Converts four items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3,
T item4,
T item5)
Converts five items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6)
Converts six items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7)
Converts seven items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7,
T item8)
Converts eight items into an ObservableSource 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> Observable<T> |
Observable.just(T item1,
T item2,
T item3,
T item4,
T item5,
T item6,
T item7,
T item8,
T item9)
Converts nine items into an ObservableSource 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.
|
static <T> Observable<T> |
Observable.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 an ObservableSource that emits those items.
|
Single<T> |
Flowable.last(T defaultItem)
Returns a Single that emits only the last item emitted by this Flowable, or a default item
if this Flowable completes without emitting any items.
|
Single<T> |
Observable.last(T defaultItem)
Returns a Single that emits only the last item emitted by this Observable, or a default item
if this Observable completes without emitting any items.
|
Maybe<T> |
Flowable.lastElement()
Returns a Maybe that emits the last item emitted by this Flowable or completes if
this Flowable is empty.
|
Maybe<T> |
Observable.lastElement()
Returns a Maybe that emits the last item emitted by this Observable or
completes if this Observable is empty.
|
Single<T> |
Flowable.lastOrError()
Returns a Single that emits only the last item emitted by this Flowable or signals
a
NoSuchElementException if this Flowable is empty. |
Single<T> |
Observable.lastOrError()
Returns a Single that emits only the last item emitted by this Observable or
signals a
NoSuchElementException if this Observable is empty. |
Completable |
Completable.lift(CompletableOperator onLift)
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns a
Completable which, when subscribed to, invokes the apply(CompletableObserver) method
of the provided CompletableOperator for each individual downstream Completable and allows the
insertion of a custom operator by accessing the downstream's CompletableObserver during this subscription phase
and providing a new CompletableObserver , containing the custom operator's intended business logic, that will be
used in the subscription process going further upstream. |
<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. |
<R> Maybe<R> |
Maybe.lift(MaybeOperator<? extends R,? super T> lift)
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns a
Maybe which, when subscribed to, invokes the apply(MaybeObserver) method
of the provided MaybeOperator for each individual downstream Maybe and allows the
insertion of a custom operator by accessing the downstream's MaybeObserver during this subscription phase
and providing a new MaybeObserver , containing the custom operator's intended business logic, that will be
used in the subscription process going further upstream. |
<R> Observable<R> |
Observable.lift(ObservableOperator<? extends R,? super T> lifter)
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns an
Observable which, when subscribed to, invokes the apply(Observer) method
of the provided ObservableOperator for each individual downstream Observer and allows the
insertion of a custom operator by accessing the downstream's Observer during this subscription phase
and providing a new Observer , containing the custom operator's intended business logic, that will be
used in the subscription process going further upstream. |
<R> Single<R> |
Single.lift(SingleOperator<? extends R,? super T> lift)
This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns a
Single which, when subscribed to, invokes the apply(SingleObserver) method
of the provided SingleOperator for each individual downstream Single and allows the
insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase
and providing a new SingleObserver , 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> Maybe<R> |
Maybe.map(Function<? super T,? extends R> mapper)
Returns a Maybe that applies a specified function to the item emitted by the source Maybe and
emits the result of this function application.
|
<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.
|
<R> Single<R> |
Single.map(Function<? super T,? extends R> mapper)
Returns a Single that applies a specified function to the item emitted by the source Single and
emits the result of this function application.
|
<R> Observable<R> |
Observable.map(Function<? super T,? extends R> mapper)
Returns an Observable that applies a specified function to each item emitted by the source ObservableSource 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. |
Observable<Notification<T>> |
Observable.materialize()
Returns an Observable that represents all of the emissions and notifications from the source
ObservableSource into emissions marked with their original types within
Notification objects. |
static Completable |
Completable.merge(Iterable<? extends CompletableSource> sources)
Returns a Completable instance that subscribes to all sources at once and
completes only when all source Completables complete or one of them emits an error.
|
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> Observable<T> |
Observable.merge(Iterable<? extends ObservableSource<? extends T>> sources)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation.
|
static <T> Observable<T> |
Observable.merge(Iterable<? extends ObservableSource<? extends T>> sources,
int maxConcurrency)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the
number of concurrent subscriptions to these ObservableSources.
|
static <T> Observable<T> |
Observable.merge(Iterable<? extends ObservableSource<? extends T>> sources,
int maxConcurrency,
int bufferSize)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the
number of concurrent subscriptions to these ObservableSources.
|
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> Maybe<T> |
Maybe.merge(MaybeSource<? extends MaybeSource<? extends T>> source)
Flattens a
MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item
emitted by the nested MaybeSource , without any transformation. |
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Flattens two MaybeSources into a single Flowable, without any transformation.
|
static <T> Flowable<T> |
Maybe.merge(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
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> Observable<T> |
Observable.merge(ObservableSource<? extends ObservableSource<? extends T>> sources)
Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by
those ObservableSources, without any transformation.
|
static <T> Observable<T> |
Observable.merge(ObservableSource<? extends ObservableSource<? extends T>> sources,
int maxConcurrency)
Flattens an ObservableSource that emits ObservableSources into a single ObservableSource that emits the items emitted by
those ObservableSources, without any transformation, while limiting the maximum number of concurrent
subscriptions to these ObservableSources.
|
static <T> Observable<T> |
Observable.merge(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2)
Flattens two ObservableSources into a single ObservableSource, without any transformation.
|
static <T> Observable<T> |
Observable.merge(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3)
Flattens three ObservableSources into a single ObservableSource, without any transformation.
|
static <T> Observable<T> |
Observable.merge(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3,
ObservableSource<? extends T> source4)
Flattens four ObservableSources into a single ObservableSource, without any transformation.
|
static Completable |
Completable.merge(org.reactivestreams.Publisher<? extends CompletableSource> sources)
Returns a Completable instance that subscribes to all sources at once and
completes only when all source Completables complete or one of them emits an error.
|
static Completable |
Completable.merge(org.reactivestreams.Publisher<? extends CompletableSource> sources,
int maxConcurrency)
Returns a Completable instance that keeps subscriptions to a limited number of sources at once and
completes only when all source Completables complete or one of them emits an error.
|
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> Single<T> |
Single.merge(SingleSource<? extends SingleSource<? extends T>> source)
Flattens a
Single that emits a Single into a single Single that emits the item
emitted by the nested Single , 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 Completable |
Completable.mergeArray(CompletableSource... sources)
Returns a Completable instance that subscribes to all sources at once and
completes only when all source Completables complete or one of them emits an error.
|
static <T> Observable<T> |
Observable.mergeArray(int maxConcurrency,
int bufferSize,
ObservableSource<? extends T>... sources)
Flattens an Iterable of ObservableSources into one ObservableSource, without any transformation, while limiting the
number of concurrent subscriptions to these ObservableSources.
|
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> Observable<T> |
Observable.mergeArray(ObservableSource<? extends T>... sources)
Flattens an Array of ObservableSources into one ObservableSource, without any transformation.
|
static <T> Flowable<T> |
Flowable.mergeArray(org.reactivestreams.Publisher<? extends T>... sources)
Flattens an Array of Publishers into one Publisher, without any transformation.
|
static Completable |
Completable.mergeArrayDelayError(CompletableSource... sources)
Returns a CompletableConsumable that subscribes to all Completables in the source array and delays
any error emitted by either the sources observable or any of the inner Completables until all of
them terminate in a way or another.
|
static <T> Observable<T> |
Observable.mergeArrayDelayError(int maxConcurrency,
int bufferSize,
ObservableSource<? extends T>... sources)
Flattens an array of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from each of the source ObservableSources without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
|
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> Observable<T> |
Observable.mergeArrayDelayError(ObservableSource<? extends T>... sources)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from each of the source ObservableSources 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 Completable |
Completable.mergeDelayError(Iterable<? extends CompletableSource> sources)
Returns a Completable that subscribes to all Completables in the source sequence and delays
any error emitted by either the sources observable or any of the inner Completables until all of
them terminate in a way or another.
|
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> Observable<T> |
Observable.mergeDelayError(Iterable<? extends ObservableSource<? extends T>> sources)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from each of the source ObservableSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
Observable.mergeDelayError(Iterable<? extends ObservableSource<? extends T>> sources,
int maxConcurrency)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from each of the source ObservableSources without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
|
static <T> Observable<T> |
Observable.mergeDelayError(Iterable<? extends ObservableSource<? extends T>> sources,
int maxConcurrency,
int bufferSize)
Flattens an Iterable of ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from each of the source ObservableSources without being interrupted by an error
notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.
|
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> Observable<T> |
Observable.mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources)
Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to
receive all successfully emitted items from all of the source ObservableSources without being interrupted by
an error notification from one of them.
|
static <T> Observable<T> |
Observable.mergeDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources,
int maxConcurrency)
Flattens an ObservableSource that emits ObservableSources into one ObservableSource, in a way that allows an Observer to
receive all successfully emitted items from all of the source ObservableSources without being interrupted by
an error notification from one of them, while limiting the
number of concurrent subscriptions to these ObservableSources.
|
static <T> Observable<T> |
Observable.mergeDelayError(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2)
Flattens two ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from each of the source ObservableSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
Observable.mergeDelayError(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3)
Flattens three ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from all of the source ObservableSources without being interrupted by an error
notification from one of them.
|
static <T> Observable<T> |
Observable.mergeDelayError(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
ObservableSource<? extends T> source3,
ObservableSource<? extends T> source4)
Flattens four ObservableSources into one ObservableSource, in a way that allows an Observer to receive all
successfully emitted items from all of the source ObservableSources without being interrupted by an error
notification from one of them.
|
static Completable |
Completable.mergeDelayError(org.reactivestreams.Publisher<? extends CompletableSource> sources)
Returns a Completable that subscribes to all Completables in the source sequence and delays
any error emitted by either the sources observable or any of the inner Completables until all of
them terminate in a way or another.
|
static Completable |
Completable.mergeDelayError(org.reactivestreams.Publisher<? extends CompletableSource> sources,
int maxConcurrency)
Returns a Completable that subscribes to a limited number of inner Completables at once in
the source sequence and delays any error emitted by either the sources
observable or any of the inner Completables until all of
them terminate in a way or another.
|
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.
|
Completable |
Completable.mergeWith(CompletableSource other)
Returns a Completable which subscribes to this and the other Completable and completes
when both of them complete or one emits an error.
|
Flowable<T> |
Flowable.mergeWith(CompletableSource other)
Relays the items of this Flowable and completes only when the other CompletableSource completes
as well.
|
Observable<T> |
Observable.mergeWith(CompletableSource other)
Relays the items of this Observable and completes only when the other CompletableSource completes
as well.
|
Flowable<T> |
Maybe.mergeWith(MaybeSource<? extends T> other)
Flattens this and another Maybe into a single Flowable, without any transformation.
|
Flowable<T> |
Flowable.mergeWith(MaybeSource<? extends T> other)
Merges the sequence of items of this Flowable with the success value of the other MaybeSource
or waits for both to complete normally if the MaybeSource is empty.
|
Observable<T> |
Observable.mergeWith(MaybeSource<? extends T> other)
Merges the sequence of items of this Observable with the success value of the other MaybeSource
or waits both to complete normally if the MaybeSource is empty.
|
Observable<T> |
Observable.mergeWith(ObservableSource<? extends T> other)
Flattens this and another ObservableSource into a single ObservableSource, without any transformation.
|
Flowable<T> |
Flowable.mergeWith(org.reactivestreams.Publisher<? extends T> other)
Flattens this and another Publisher into a single Publisher, 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.
|
Flowable<T> |
Single.mergeWith(SingleSource<? extends T> other)
Flattens this and another Single into a single Flowable, without any transformation.
|
Observable<T> |
Observable.mergeWith(SingleSource<? extends T> other)
Merges the sequence of items of this Observable with the success value of the other SingleSource.
|
static Completable |
Completable.never()
Returns a Completable that never calls onError or onComplete.
|
static <T> Maybe<T> |
Maybe.never()
Returns a Maybe that never sends any items or notifications to a
MaybeObserver . |
static <T> Flowable<T> |
Flowable.never()
Returns a Flowable that never sends any items or notifications to a
Subscriber . |
static <T> Single<T> |
Single.never()
Returns a singleton instance of a never-signalling Single (only calls onSubscribe).
|
static <T> Observable<T> |
Observable.never()
Returns an Observable that never sends any items or notifications to an
Observer . |
Completable |
Completable.observeOn(Scheduler scheduler)
Returns a Completable which emits the terminal events from the thread of the specified scheduler.
|
Maybe<T> |
Maybe.observeOn(Scheduler scheduler)
Wraps a Maybe to emit its item (or notify of its error) on a specified
Scheduler ,
asynchronously. |
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 Flowable.bufferSize() slots. |
Single<T> |
Single.observeOn(Scheduler scheduler)
Modifies a Single to emit its item (or notify of its error) on a specified
Scheduler ,
asynchronously. |
Observable<T> |
Observable.observeOn(Scheduler scheduler)
Modifies an ObservableSource to perform its emissions and notifications on a specified
Scheduler ,
asynchronously with an unbounded buffer with Flowable.bufferSize() "island size". |
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. |
Observable<T> |
Observable.observeOn(Scheduler scheduler,
boolean delayError)
Modifies an ObservableSource to perform its emissions and notifications on a specified
Scheduler ,
asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" 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. |
Observable<T> |
Observable.observeOn(Scheduler scheduler,
boolean delayError,
int bufferSize)
Modifies an ObservableSource to perform its emissions and notifications on a specified
Scheduler ,
asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications. |
<U> Maybe<U> |
Maybe.ofType(Class<U> clazz)
Filters the items emitted by a Maybe, only emitting its success value if that
is an instance of the supplied Class.
|
<U> Flowable<U> |
Flowable.ofType(Class<U> clazz)
Filters the items emitted by a Publisher, only emitting those of the specified type.
|
<U> Observable<U> |
Observable.ofType(Class<U> clazz)
Filters the items emitted by an ObservableSource, 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.
|
Completable |
Completable.onErrorComplete()
Returns a Completable instance that if this Completable emits an error, it will emit an onComplete
and swallow the throwable.
|
Maybe<T> |
Maybe.onErrorComplete()
Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete
and swallow the throwable.
|
Completable |
Completable.onErrorComplete(Predicate<? super Throwable> predicate)
Returns a Completable instance that if this Completable emits an error and the predicate returns
true, it will emit an onComplete and swallow the throwable.
|
Maybe<T> |
Maybe.onErrorComplete(Predicate<? super Throwable> predicate)
Returns a Maybe instance that if this Maybe emits an error and the predicate returns
true, it will emit an onComplete and swallow the throwable.
|
Completable |
Completable.onErrorResumeNext(Function<? super Throwable,? extends CompletableSource> errorMapper)
Returns a Completable instance that when encounters an error from this Completable, calls the
specified mapper function that returns another Completable instance for it and resumes the
execution with it.
|
Maybe<T> |
Maybe.onErrorResumeNext(Function<? super Throwable,? extends MaybeSource<? extends T>> resumeFunction)
Instructs a Maybe to pass control to another Maybe rather than invoking
onError if it encounters an error. |
Observable<T> |
Observable.onErrorResumeNext(Function<? super Throwable,? extends ObservableSource<? extends T>> resumeFunction)
Instructs an ObservableSource to pass control to another ObservableSource rather than invoking
onError if it encounters an error. |
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. |
Single<T> |
Single.onErrorResumeNext(Function<? super Throwable,? extends SingleSource<? extends T>> resumeFunctionInCaseOfError)
Instructs a Single to pass control to another Single rather than invoking
SingleObserver.onError(Throwable) if it encounters an error. |
Maybe<T> |
Maybe.onErrorResumeNext(MaybeSource<? extends T> next)
Instructs a Maybe to pass control to another
MaybeSource rather than invoking
onError if it encounters an error. |
Observable<T> |
Observable.onErrorResumeNext(ObservableSource<? extends T> next)
Instructs an ObservableSource to pass control to another ObservableSource 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. |
Single<T> |
Single.onErrorResumeNext(Single<? extends T> resumeSingleInCaseOfError)
Instructs a Single to pass control to another Single rather than invoking
SingleObserver.onError(Throwable) if it encounters an error. |
Maybe<T> |
Maybe.onErrorReturn(Function<? super Throwable,? extends T> valueSupplier)
Instructs a Maybe to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
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. |
Observable<T> |
Observable.onErrorReturn(Function<? super Throwable,? extends T> valueSupplier)
Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Single<T> |
Single.onErrorReturn(Function<Throwable,? extends T> resumeFunction)
Instructs a Single to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Maybe<T> |
Maybe.onErrorReturnItem(T item)
Instructs a Maybe 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. |
Single<T> |
Single.onErrorReturnItem(T value)
Signals the specified value as success in case the current Single signals an error.
|
Observable<T> |
Observable.onErrorReturnItem(T item)
Instructs an ObservableSource to emit an item (returned by a specified function) rather than invoking
onError if it encounters an error. |
Maybe<T> |
Maybe.onExceptionResumeNext(MaybeSource<? extends T> next)
|
Observable<T> |
Observable.onExceptionResumeNext(ObservableSource<? extends T> next)
|
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 . |
Completable |
Completable.onTerminateDetach()
Nulls out references to the upstream producer and downstream CompletableObserver if
the sequence is terminated or downstream calls dispose().
|
Maybe<T> |
Maybe.onTerminateDetach()
Nulls out references to the upstream producer and downstream MaybeObserver if
the sequence is terminated or downstream calls dispose().
|
Flowable<T> |
Flowable.onTerminateDetach()
Nulls out references to the upstream producer and downstream Subscriber if
the sequence is terminated or downstream cancels.
|
Single<T> |
Single.onTerminateDetach()
Nulls out references to the upstream producer and downstream SingleObserver if
the sequence is terminated or downstream calls dispose().
|
Observable<T> |
Observable.onTerminateDetach()
Nulls out references to the upstream producer and downstream Observer if
the sequence is terminated or downstream calls dispose().
|
ParallelFlowable<T> |
Flowable.parallel()
Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs)
and dispatches the upstream items to them in a round-robin fashion.
|
ParallelFlowable<T> |
Flowable.parallel(int parallelism)
Parallelizes the flow by creating the specified number of 'rails'
and dispatches the upstream items to them in a round-robin fashion.
|
ParallelFlowable<T> |
Flowable.parallel(int parallelism,
int prefetch)
Parallelizes the flow by creating the specified number of 'rails'
and dispatches the upstream items to them in a round-robin fashion and
uses the defined per-'rail' prefetch amount.
|
ConnectableFlowable<T> |
Flowable.publish()
Returns a
ConnectableFlowable , which is a variety of Publisher that waits until its
connect method is called before it begins emitting items to those
Subscriber s that have subscribed to it. |
ConnectableObservable<T> |
Observable.publish()
Returns a
ConnectableObservable , which is a variety of ObservableSource that waits until its
connect method is called before it begins emitting items to those
Observer s that have subscribed to it. |
<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. |
<R> Observable<R> |
Observable.publish(Function<? super Observable<T>,? extends ObservableSource<R>> selector)
Returns an Observable that emits the results of invoking a specified selector on items emitted by a
ConnectableObservable that shares a single subscription to the underlying sequence. |
ConnectableFlowable<T> |
Flowable.publish(int bufferSize)
Returns a
ConnectableFlowable , which is a variety of Publisher that waits until its
connect method is called before it begins emitting items to those
Subscriber s that have subscribed to it. |
static Flowable<Integer> |
Flowable.range(int start,
int count)
Returns a Flowable that emits a sequence of Integers within a specified range.
|
static Observable<Integer> |
Observable.range(int start,
int count)
Returns an Observable 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.
|
static Observable<Long> |
Observable.rangeLong(long start,
long count)
Returns an Observable 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. |
Maybe<T> |
Flowable.reduce(BiFunction<T,T,T> reducer)
Returns a Maybe 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 finite source Publisher,
and emits the final result from the final call to your function as its sole item.
|
Maybe<T> |
Observable.reduce(BiFunction<T,T,T> reducer)
Returns a Maybe that applies a specified accumulator function to the first item emitted by a source
ObservableSource, then feeds the result of that function along with the second item emitted by the source
ObservableSource into the same function, and so on until all items have been emitted by the finite source ObservableSource,
and emits the final result from the final call to your function as its sole item.
|
<R> Single<R> |
Flowable.reduce(R seed,
BiFunction<R,? super T,R> reducer)
Returns a Single that applies a specified accumulator function to the first item emitted by a source
Publisher and a specified seed value, then feeds the result of that function along with the second item
emitted by a Publisher into the same function, and so on until all items have been emitted by the
finite source Publisher, emitting the final result from the final call to your function as its sole item.
|
<R> Single<R> |
Observable.reduce(R seed,
BiFunction<R,? super T,R> reducer)
Returns a Single that applies a specified accumulator function to the first item emitted by a source
ObservableSource and a specified seed value, then feeds the result of that function along with the second item
emitted by an ObservableSource into the same function, and so on until all items have been emitted by the
finite source ObservableSource, emitting the final result from the final call to your function as its sole item.
|
<R> Single<R> |
Flowable.reduceWith(Callable<R> seedSupplier,
BiFunction<R,? super T,R> reducer)
Returns a Single that applies a specified accumulator function to the first item emitted by a source
Publisher and a seed value derived from calling a specified seedSupplier, then feeds the result
of that function along with the second item emitted by a Publisher into the same function, and so on until
all items have been emitted by the finite source Publisher, emitting the final result from the final call to your
function as its sole item.
|
<R> Single<R> |
Observable.reduceWith(Callable<R> seedSupplier,
BiFunction<R,? super T,R> reducer)
Returns a Single that applies a specified accumulator function to the first item emitted by a source
ObservableSource and a seed value derived from calling a specified seedSupplier, then feeds the result
of that function along with the second item emitted by an ObservableSource into the same function,
and so on until all items have been emitted by the finite source ObservableSource, emitting the final result
from the final call to your function as its sole item.
|
Completable |
Completable.repeat()
Returns a Completable that repeatedly subscribes to this Completable until cancelled.
|
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()
Repeatedly re-subscribes to the current Single and emits each success value.
|
Observable<T> |
Observable.repeat()
Returns an Observable that repeats the sequence of items emitted by the source ObservableSource indefinitely.
|
Completable |
Completable.repeat(long times)
Returns a Completable that subscribes repeatedly at most the given times to this Completable.
|
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.repeat(long times)
Re-subscribes to the current Single at most the given number of times and emits each success value.
|
Observable<T> |
Observable.repeat(long times)
Returns an Observable that repeats the sequence of items emitted by the source ObservableSource at most
count times. |
Completable |
Completable.repeatUntil(BooleanSupplier stop)
Returns a Completable that repeatedly subscribes to this Completable so long as the given
stop supplier returns false.
|
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.repeatUntil(BooleanSupplier stop)
Re-subscribes to the current Single until the given BooleanSupplier returns true.
|
Observable<T> |
Observable.repeatUntil(BooleanSupplier stop)
Returns an Observable that repeats the sequence of items emitted by the source ObservableSource until
the provided stop function returns true.
|
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.
|
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 . |
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.
|
Observable<T> |
Observable.repeatWhen(Function<? super Observable<Object>,? extends ObservableSource<?>> handler)
Returns an Observable that emits the same values as the source ObservableSource with the exception of an
onComplete . |
ConnectableFlowable<T> |
Flowable.replay()
Returns a
ConnectableFlowable that shares a single subscription to the underlying Publisher
that will replay all of its items and notifications to any future Subscriber . |
ConnectableObservable<T> |
Observable.replay()
Returns a
ConnectableObservable that shares a single subscription to the underlying ObservableSource
that will replay all of its items and notifications to any future Observer . |
<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. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector)
Returns an Observable that emits items that are the results of invoking a specified selector on the items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
int bufferSize)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource,
replaying bufferSize notifications. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
int bufferSize,
long time,
TimeUnit unit)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource,
replaying no more than bufferSize items that were emitted within a specified time window. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
int bufferSize,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource,
replaying no more than bufferSize items that were emitted within a specified time window. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
int bufferSize,
Scheduler scheduler)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource,
replaying a maximum of bufferSize items. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
long time,
TimeUnit unit)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource,
replaying all items that were emitted within a specified time window. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource,
replaying all items that were emitted within a specified time window. |
<R> Observable<R> |
Observable.replay(Function<? super Observable<T>,? extends ObservableSource<R>> selector,
Scheduler scheduler)
Returns an Observable that emits items that are the results of invoking a specified selector on items
emitted by a
ConnectableObservable that shares a single subscription to the source ObservableSource. |
ConnectableFlowable<T> |
Flowable.replay(int bufferSize)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher that
replays at most bufferSize items emitted by that Publisher. |
ConnectableObservable<T> |
Observable.replay(int bufferSize)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource that
replays at most bufferSize items emitted by that ObservableSource. |
ConnectableFlowable<T> |
Flowable.replay(int bufferSize,
long time,
TimeUnit unit)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher and
replays at most bufferSize items that were emitted during a specified time window. |
ConnectableObservable<T> |
Observable.replay(int bufferSize,
long time,
TimeUnit unit)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource and
replays at most bufferSize items that were emitted during a specified time window. |
ConnectableFlowable<T> |
Flowable.replay(int bufferSize,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher and
that replays a maximum of bufferSize items that are emitted within a specified time window. |
ConnectableObservable<T> |
Observable.replay(int bufferSize,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource and
that replays a maximum of bufferSize items that are emitted within a specified time window. |
ConnectableFlowable<T> |
Flowable.replay(int bufferSize,
Scheduler scheduler)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher and
replays at most bufferSize items emitted by that Publisher. |
ConnectableObservable<T> |
Observable.replay(int bufferSize,
Scheduler scheduler)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource and
replays at most bufferSize items emitted by that ObservableSource. |
ConnectableFlowable<T> |
Flowable.replay(long time,
TimeUnit unit)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher and
replays all items emitted by that Publisher within a specified time window. |
ConnectableObservable<T> |
Observable.replay(long time,
TimeUnit unit)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource and
replays all items emitted by that ObservableSource within a specified time window. |
ConnectableFlowable<T> |
Flowable.replay(long time,
TimeUnit unit,
Scheduler scheduler)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher and
replays all items emitted by that Publisher within a specified time window. |
ConnectableObservable<T> |
Observable.replay(long time,
TimeUnit unit,
Scheduler scheduler)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource and
replays all items emitted by that ObservableSource within a specified time window. |
ConnectableFlowable<T> |
Flowable.replay(Scheduler scheduler)
Returns a
ConnectableFlowable that shares a single subscription to the source Publisher that
will replay all of its items and notifications to any future Subscriber on the given
Scheduler . |
ConnectableObservable<T> |
Observable.replay(Scheduler scheduler)
Returns a
ConnectableObservable that shares a single subscription to the source ObservableSource that
will replay all of its items and notifications to any future Observer on the given
Scheduler . |
Completable |
Completable.retry()
Returns a Completable that retries this Completable as long as it emits an onError event.
|
Maybe<T> |
Maybe.retry()
Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls
onError
(infinite retry count). |
Flowable<T> |
Flowable.retry()
Returns a Flowable that mirrors the source Publisher, resubscribing to it if it calls
onError
(infinite retry count). |
Single<T> |
Single.retry()
Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.
|
Observable<T> |
Observable.retry()
Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls
onError
(infinite retry count). |
Completable |
Completable.retry(BiPredicate<? super Integer,? super Throwable> predicate)
Returns a Completable that retries this Completable in case of an error as long as the predicate
returns true.
|
Maybe<T> |
Maybe.retry(BiPredicate<? super Integer,? super Throwable> predicate)
Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls
onError
and the predicate returns true for that specific exception and retry count. |
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. |
Single<T> |
Single.retry(BiPredicate<? super Integer,? super Throwable> predicate)
Re-subscribe to the current Single if the given predicate returns true when the Single fails
with an onError.
|
Observable<T> |
Observable.retry(BiPredicate<? super Integer,? super Throwable> predicate)
Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls
onError
and the predicate returns true for that specific exception and retry count. |
Completable |
Completable.retry(long times)
Returns a Completable that when this Completable emits an error, retries at most the given
number of times before giving up and emitting the last error.
|
Maybe<T> |
Maybe.retry(long count)
Returns a Maybe that mirrors the source Maybe, resubscribing to it if it calls
onError
up to a specified number of retries. |
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. |
Single<T> |
Single.retry(long times)
Repeatedly re-subscribe at most the specified times to the current Single
if it fails with an onError.
|
Observable<T> |
Observable.retry(long times)
Returns an Observable that mirrors the source ObservableSource, resubscribing to it if it calls
onError
up to a specified number of retries. |
Completable |
Completable.retry(long times,
Predicate<? super Throwable> predicate)
Returns a Completable that when this Completable emits an error, retries at most times
or until the predicate returns false, whichever happens first and emitting the last error.
|
Maybe<T> |
Maybe.retry(long times,
Predicate<? super Throwable> predicate)
Retries at most times or until the predicate returns false, whichever happens first.
|
Flowable<T> |
Flowable.retry(long times,
Predicate<? super Throwable> predicate)
Retries at most times or until the predicate returns false, whichever happens first.
|
Single<T> |
Single.retry(long times,
Predicate<? super Throwable> predicate)
Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first
if it fails with an onError.
|
Observable<T> |
Observable.retry(long times,
Predicate<? super Throwable> predicate)
Retries at most times or until the predicate returns false, whichever happens first.
|
Completable |
Completable.retry(Predicate<? super Throwable> predicate)
Returns a Completable that when this Completable emits an error, calls the given predicate with
the latest exception to decide whether to resubscribe to this or not.
|
Maybe<T> |
Maybe.retry(Predicate<? super Throwable> predicate)
Retries the current Maybe if it fails and the predicate returns true.
|
Flowable<T> |
Flowable.retry(Predicate<? super Throwable> predicate)
Retries the current Flowable if the predicate returns true.
|
Single<T> |
Single.retry(Predicate<? super Throwable> predicate)
Re-subscribe to the current Single if the given predicate returns true when the Single fails
with an onError.
|
Observable<T> |
Observable.retry(Predicate<? super Throwable> predicate)
Retries the current Observable if the predicate returns true.
|
Maybe<T> |
Maybe.retryUntil(BooleanSupplier stop)
Retries until the given stop function returns true.
|
Flowable<T> |
Flowable.retryUntil(BooleanSupplier stop)
Retries until the given stop function returns true.
|
Observable<T> |
Observable.retryUntil(BooleanSupplier stop)
Retries until the given stop function returns true.
|
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.
|
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 . |
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.
|
Observable<T> |
Observable.retryWhen(Function<? super Observable<Throwable>,? extends ObservableSource<?>> handler)
Returns an Observable that emits the same values as the source ObservableSource with the exception of an
onError . |
void |
Observable.safeSubscribe(Observer<? super T> s)
Subscribes to the current Observable and wraps the given Observer into a SafeObserver
(if not already a SafeObserver) that
deals with exceptions thrown by a misbehaving Observer (that doesn't follow the
Reactive-Streams specification).
|
void |
Flowable.safeSubscribe(org.reactivestreams.Subscriber<? super T> s)
Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber
(if not already a SafeSubscriber) that
deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the
Reactive-Streams specification).
|
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.
|
Observable<T> |
Observable.sample(long period,
TimeUnit unit)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource
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.
|
Observable<T> |
Observable.sample(long period,
TimeUnit unit,
boolean emitLast)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource
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.
|
Observable<T> |
Observable.sample(long period,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource
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.
|
Observable<T> |
Observable.sample(long period,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast)
Returns an Observable that emits the most recently emitted item (if any) emitted by the source ObservableSource
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> Observable<T> |
Observable.sample(ObservableSource<U> sampler)
Returns an Observable that, when the specified
sampler ObservableSource emits an item or completes,
emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous
emission from the sampler ObservableSource. |
<U> Observable<T> |
Observable.sample(ObservableSource<U> sampler,
boolean emitLast)
Returns an Observable that, when the specified
sampler ObservableSource emits an item or completes,
emits the most recently emitted item (if any) emitted by the source ObservableSource since the previous
emission from the sampler ObservableSource
and optionally emit the very last upstream item when the upstream or other ObservableSource complete. |
<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.
|
Observable<T> |
Observable.scan(BiFunction<T,T,T> accumulator)
Returns an Observable that applies a specified accumulator function to the first item emitted by a source
ObservableSource, then feeds the result of that function along with the second item emitted by the source
ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource,
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> Observable<R> |
Observable.scan(R initialValue,
BiFunction<R,? super T,R> accumulator)
Returns an Observable that applies a specified accumulator function to the first item emitted by a source
ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by
the source ObservableSource into the same function, and so on until all items have been emitted by the source
ObservableSource, 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.
|
<R> Observable<R> |
Observable.scanWith(Callable<R> seedSupplier,
BiFunction<R,? super T,R> accumulator)
Returns an Observable that applies a specified accumulator function to the first item emitted by a source
ObservableSource and a seed value, then feeds the result of that function along with the second item emitted by
the source ObservableSource into the same function, and so on until all items have been emitted by the source
ObservableSource, emitting the result of each of these iterations.
|
static <T> Single<Boolean> |
Maybe.sequenceEqual(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2)
Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the
same by comparing the items emitted by each MaybeSource pairwise.
|
static <T> Single<Boolean> |
Maybe.sequenceEqual(MaybeSource<? extends T> source1,
MaybeSource<? extends T> source2,
BiPredicate<? super T,? super T> isEqual)
Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the
same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified
equality function.
|
static <T> Single<Boolean> |
Observable.sequenceEqual(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2)
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise.
|
static <T> Single<Boolean> |
Observable.sequenceEqual(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
BiPredicate<? super T,? super T> isEqual)
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified
equality function.
|
static <T> Single<Boolean> |
Observable.sequenceEqual(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
BiPredicate<? super T,? super T> isEqual,
int bufferSize)
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified
equality function.
|
static <T> Single<Boolean> |
Observable.sequenceEqual(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
int bufferSize)
Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the
same by comparing the items emitted by each ObservableSource pairwise.
|
static <T> Single<Boolean> |
Flowable.sequenceEqual(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2)
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise.
|
static <T> Single<Boolean> |
Flowable.sequenceEqual(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
BiPredicate<? super T,? super T> isEqual)
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise based on the results of a specified
equality function.
|
static <T> Single<Boolean> |
Flowable.sequenceEqual(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
BiPredicate<? super T,? super T> isEqual,
int bufferSize)
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise based on the results of a specified
equality function.
|
static <T> Single<Boolean> |
Flowable.sequenceEqual(org.reactivestreams.Publisher<? extends T> source1,
org.reactivestreams.Publisher<? extends T> source2,
int bufferSize)
Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the
same by comparing the items emitted by each Publisher pairwise.
|
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.
|
Observable<T> |
Observable.serialize()
Forces an ObservableSource's emissions and notifications to be serialized and for it to obey
the ObservableSource contract in other ways.
|
Flowable<T> |
Flowable.share()
Returns a new
Publisher that multicasts (and shares a single subscription to) the original Publisher . |
Observable<T> |
Observable.share()
Returns a new
ObservableSource that multicasts (and shares a single subscription to) the original ObservableSource . |
Single<T> |
Flowable.single(T defaultItem)
Returns a Single that emits the single item emitted by the source Publisher, if that Publisher
emits only a single item, or a default item if the source Publisher emits no items.
|
Single<T> |
Observable.single(T defaultItem)
Returns a Single that emits the single item emitted by this Observable, if this Observable
emits only a single item, or a default item if the source ObservableSource emits no items.
|
Maybe<T> |
Flowable.singleElement()
Returns a Maybe that completes if this Flowable is empty, signals one item if this Flowable
signals exactly one item or signals an
IllegalArgumentException if this Flowable signals
more than one item. |
Maybe<T> |
Observable.singleElement()
Returns a Maybe that completes if this Observable is empty or emits the single item emitted by this Observable,
or signals an
IllegalArgumentException if this Observable emits more than one item. |
Single<T> |
Flowable.singleOrError()
Returns a Single that emits the single item emitted by this Flowable, if this Flowable
emits only a single item, otherwise
if this Flowable completes without emitting any items a
NoSuchElementException will be signaled and
if this Flowable emits more than one item, an IllegalArgumentException will be signaled. |
Single<T> |
Observable.singleOrError()
Returns a Single that emits the single item emitted by this Observable if this Observable
emits only a single item, otherwise
if this Observable completes without emitting any items or emits more than one item a
NoSuchElementException or IllegalArgumentException will be signalled respectively. |
Flowable<T> |
Flowable.skip(long count)
Returns a Flowable that skips the first
count items emitted by the source Publisher and emits
the remainder. |
Observable<T> |
Observable.skip(long count)
Returns an Observable that skips the first
count items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.skip(long time,
TimeUnit unit)
Returns an Observable that skips values emitted by the source ObservableSource 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. |
Observable<T> |
Observable.skip(long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that skips values emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.skipLast(int count)
Returns an Observable that drops a specified number of items from the end of the sequence emitted by the
source ObservableSource.
|
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.
|
Observable<T> |
Observable.skipLast(long time,
TimeUnit unit)
Returns an Observable that drops items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.skipLast(long time,
TimeUnit unit,
boolean delayError)
Returns an Observable that drops items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.skipLast(long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that drops items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.skipLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns an Observable that drops items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.skipLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError,
int bufferSize)
Returns an Observable that drops items emitted by the source ObservableSource during a specified time window
(defined on a specified scheduler) before the source completes.
|
<U> Observable<T> |
Observable.skipUntil(ObservableSource<U> other)
Returns an Observable that skips items emitted by the source ObservableSource until a second ObservableSource emits
an item.
|
<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.
|
Observable<T> |
Observable.skipWhile(Predicate<? super T> predicate)
Returns an Observable that skips all items emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.sorted()
Returns an Observable that emits the events emitted by source ObservableSource, 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.
|
Observable<T> |
Observable.sorted(Comparator<? super T> sortFunction)
Returns an Observable that emits the events emitted by source ObservableSource, in a
sorted order based on a specified comparison function.
|
Completable |
Completable.startWith(CompletableSource other)
Returns a Completable which first runs the other Completable
then this completable if the other completed normally.
|
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. |
Observable<T> |
Observable.startWith(Iterable<? extends T> items)
Returns an Observable that emits the items in a specified
Iterable before it begins to emit items
emitted by the source ObservableSource. |
<T> Observable<T> |
Completable.startWith(Observable<T> other)
Returns an Observable which first delivers the events
of the other Observable then runs this CompletableConsumable.
|
Observable<T> |
Observable.startWith(ObservableSource<? extends T> other)
Returns an Observable that emits the items in a specified
ObservableSource before it begins to emit
items emitted by the source ObservableSource. |
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.
|
Observable<T> |
Observable.startWith(T item)
Returns an Observable that emits a specified item before it begins to emit items emitted by the source
ObservableSource.
|
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.
|
Observable<T> |
Observable.startWithArray(T... items)
Returns an Observable that emits the specified items before it begins to emit items emitted by the source
ObservableSource.
|
Disposable |
Completable.subscribe()
Subscribes to this CompletableConsumable and returns a Disposable which can be used to cancel
the subscription.
|
Disposable |
Maybe.subscribe()
Subscribes to a Maybe and ignores
onSuccess and onComplete emissions. |
Disposable |
Flowable.subscribe()
Subscribes to a Publisher and ignores
onNext and onComplete emissions. |
Disposable |
Single.subscribe()
Subscribes to a Single but ignore its emission or notification.
|
Disposable |
Observable.subscribe()
Subscribes to an ObservableSource and ignores
onNext and onComplete emissions. |
Disposable |
Completable.subscribe(Action onComplete)
Subscribes to this Completable and calls the given Action when this Completable
completes normally.
|
Disposable |
Completable.subscribe(Action onComplete,
Consumer<? super Throwable> onError)
Subscribes to this Completable and calls back either the onError or onComplete functions.
|
Disposable |
Single.subscribe(BiConsumer<? super T,? super Throwable> onCallback)
Subscribes to a Single and provides a composite callback to handle the item it emits
or any error notification it issues.
|
void |
Completable.subscribe(CompletableObserver s) |
Disposable |
Maybe.subscribe(Consumer<? super T> onSuccess)
Subscribes to a Maybe and provides a callback to handle the items it emits.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext)
Subscribes to a Publisher and provides a callback to handle the items it emits.
|
Disposable |
Single.subscribe(Consumer<? super T> onSuccess)
Subscribes to a Single and provides a callback to handle the item it emits.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext)
Subscribes to an ObservableSource and provides a callback to handle the items it emits.
|
Disposable |
Maybe.subscribe(Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError)
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error
notification it issues.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to a Publisher and provides callbacks to handle the items it emits and any error
notification it issues.
|
Disposable |
Single.subscribe(Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError)
Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it
issues.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error
notification it issues.
|
Disposable |
Maybe.subscribe(Consumer<? super T> onSuccess,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Observable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super Disposable> onSubscribe)
Subscribes to an ObservableSource and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
Disposable |
Flowable.subscribe(Consumer<? super T> onNext,
Consumer<? super Throwable> onError,
Action onComplete,
Consumer<? super org.reactivestreams.Subscription> onSubscribe)
Subscribes to a Publisher and provides callbacks to handle the items it emits and any error or
completion notification it issues.
|
void |
Flowable.subscribe(FlowableSubscriber<? super T> s)
Establish a connection between this Flowable and the given FlowableSubscriber and
start streaming events based on the demand of the FlowableSubscriber.
|
void |
Maybe.subscribe(MaybeObserver<? super T> observer) |
void |
Observable.subscribe(Observer<? super T> observer) |
void |
Single.subscribe(SingleObserver<? super T> subscriber) |
void |
Flowable.subscribe(org.reactivestreams.Subscriber<? super T> s) |
Completable |
Completable.subscribeOn(Scheduler scheduler)
Returns a Completable which subscribes the child subscriber on the specified scheduler, making
sure the subscription side-effects happen on that specific thread of the scheduler.
|
Maybe<T> |
Maybe.subscribeOn(Scheduler scheduler)
Asynchronously subscribes subscribers to this Maybe on the specified
Scheduler . |
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler)
Asynchronously subscribes Subscribers to this Publisher on the specified
Scheduler . |
Single<T> |
Single.subscribeOn(Scheduler scheduler)
Asynchronously subscribes subscribers to this Single on the specified
Scheduler . |
Observable<T> |
Observable.subscribeOn(Scheduler scheduler)
Asynchronously subscribes Observers to this ObservableSource on the specified
Scheduler . |
Flowable<T> |
Flowable.subscribeOn(Scheduler scheduler,
boolean requestOn)
|
<E extends CompletableObserver> |
Completable.subscribeWith(E observer)
Subscribes a given CompletableObserver (subclass) to this Completable and returns the given
CompletableObserver as is.
|
<E extends MaybeObserver<? super T>> |
Maybe.subscribeWith(E observer)
Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given
MaybeObserver as is.
|
<E extends Observer<? super T>> |
Observable.subscribeWith(E observer)
Subscribes a given Observer (subclass) to this Observable and returns the given
Observer as is.
|
<E extends SingleObserver<? super T>> |
Single.subscribeWith(E observer)
Subscribes a given SingleObserver (subclass) to this Single and returns the given
SingleObserver as is.
|
<E extends org.reactivestreams.Subscriber<? super T>> |
Flowable.subscribeWith(E subscriber)
Subscribes a given Subscriber (subclass) to this Flowable and returns the given
Subscriber as is.
|
Maybe<T> |
Maybe.switchIfEmpty(MaybeSource<? extends T> other)
Returns a Maybe that emits the items emitted by the source Maybe or the items of an alternate
MaybeSource if the current Maybe is empty.
|
Observable<T> |
Observable.switchIfEmpty(ObservableSource<? extends T> other)
Returns an Observable that emits the items emitted by the source ObservableSource or the items of an alternate
ObservableSource if the source ObservableSource is empty.
|
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.
|
Single<T> |
Maybe.switchIfEmpty(SingleSource<? extends T> other)
Returns a Single that emits the items emitted by the source Maybe or the item of an alternate
SingleSource if the current Maybe is empty.
|
<R> Observable<R> |
Observable.switchMap(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted
of these ObservableSources.
|
<R> Observable<R> |
Observable.switchMap(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int bufferSize)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted
of these ObservableSources.
|
<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.
|
Completable |
Flowable.switchMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
Completable |
Observable.switchMapCompletable(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running. |
Completable |
Flowable.switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running and delaying any main or inner errors until all
of them terminate. |
Completable |
Observable.switchMapCompletableDelayError(Function<? super T,? extends CompletableSource> mapper)
Maps the upstream values into
CompletableSource s, subscribes to the newer one while
disposing the subscription to the previous CompletableSource , thus keeping at most one
active CompletableSource running and delaying any main or inner errors until all
of them terminate. |
<R> Observable<R> |
Observable.switchMapDelayError(Function<? super T,? extends ObservableSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted
of these ObservableSources and delays any error until all ObservableSources terminate.
|
<R> Observable<R> |
Observable.switchMapDelayError(Function<? super T,? extends ObservableSource<? extends R>> mapper,
int bufferSize)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns an ObservableSource, and then emitting the items emitted by the most recently emitted
of these ObservableSources and delays any error until all ObservableSources terminate.
|
<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> Observable<R> |
Observable.switchMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available while failing immediately if this Observable or any of the
active inner MaybeSource s fail. |
<R> Flowable<R> |
Flowable.switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available, delaying errors from this Flowable or the inner MaybeSource s until all terminate. |
<R> Observable<R> |
Observable.switchMapMaybeDelayError(Function<? super T,? extends MaybeSource<? extends R>> mapper)
Maps the upstream items into
MaybeSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if
available, delaying errors from this Observable or the inner MaybeSource s until all terminate. |
<R> Flowable<R> |
Flowable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one
while failing immediately if this Flowable or any of the
active inner SingleSource s fail. |
<R> Observable<R> |
Observable.switchMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted
of these SingleSources.
|
<R> Flowable<R> |
Flowable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Maps the upstream items into
SingleSource s and switches (subscribes) to the newer ones
while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one,
delaying errors from this Flowable or the inner SingleSource s until all terminate. |
<R> Observable<R> |
Observable.switchMapSingleDelayError(Function<? super T,? extends SingleSource<? extends R>> mapper)
Returns a new ObservableSource by applying a function that you supply to each item emitted by the source
ObservableSource that returns a SingleSource, and then emitting the item emitted by the most recently emitted
of these SingleSources and delays any error until all SingleSources terminate.
|
static <T> Observable<T> |
Observable.switchOnNext(ObservableSource<? extends ObservableSource<? extends T>> sources)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the
most recently emitted of those ObservableSources.
|
static <T> Observable<T> |
Observable.switchOnNext(ObservableSource<? extends ObservableSource<? extends T>> sources,
int bufferSize)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the
most recently emitted of those ObservableSources.
|
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> Observable<T> |
Observable.switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the
most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
|
static <T> Observable<T> |
Observable.switchOnNextDelayError(ObservableSource<? extends ObservableSource<? extends T>> sources,
int prefetch)
Converts an ObservableSource that emits ObservableSources into an ObservableSource that emits the items emitted by the
most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.
|
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. |
Observable<T> |
Observable.take(long count)
Returns an Observable that emits only the first
count items emitted by the source ObservableSource. |
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.
|
Observable<T> |
Observable.take(long time,
TimeUnit unit)
Returns an Observable that emits those items emitted by source ObservableSource 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.
|
Observable<T> |
Observable.take(long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits those items emitted by source ObservableSource 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. |
Observable<T> |
Observable.takeLast(int count)
Returns an Observable that emits at most the last
count items emitted by the source ObservableSource. |
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.
|
Observable<T> |
Observable.takeLast(long count,
long time,
TimeUnit unit)
Returns an Observable that emits at most a specified number of items from the source ObservableSource that were
emitted in a specified window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long count,
long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits at most a specified number of items from the source ObservableSource that were
emitted in a specified window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long count,
long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError,
int bufferSize)
Returns an Observable that emits at most a specified number of items from the source ObservableSource that were
emitted in a specified window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long time,
TimeUnit unit)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified
window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long time,
TimeUnit unit,
boolean delayError)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified
window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long time,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified
window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified
window of time before the ObservableSource 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.
|
Observable<T> |
Observable.takeLast(long time,
TimeUnit unit,
Scheduler scheduler,
boolean delayError,
int bufferSize)
Returns an Observable that emits the items from the source ObservableSource that were emitted in a specified
window of time before the ObservableSource completed, where the timing information is provided by a specified
Scheduler.
|
Single<T> |
Single.takeUntil(CompletableSource other)
Returns a Single that emits the item emitted by the source Single until a Completable terminates.
|
<U> Maybe<T> |
Maybe.takeUntil(MaybeSource<U> other)
Returns a Maybe that emits the items emitted by the source Maybe until a second MaybeSource
emits an item.
|
<U> Observable<T> |
Observable.takeUntil(ObservableSource<U> other)
Returns an Observable that emits the items emitted by the source Observable until a second ObservableSource
emits an item.
|
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.
|
Observable<T> |
Observable.takeUntil(Predicate<? super T> stopPredicate)
Returns an Observable that emits items emitted by the source Observable, checks the specified predicate
for each item, and then completes when the condition is satisfied.
|
<E> Single<T> |
Single.takeUntil(org.reactivestreams.Publisher<E> other)
Returns a Single that emits the item emitted by the source Single until a Publisher emits an item.
|
<U> Maybe<T> |
Maybe.takeUntil(org.reactivestreams.Publisher<U> other)
Returns a Maybe that emits the item emitted by the source Maybe until a second Publisher
emits an item.
|
<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.
|
<E> Single<T> |
Single.takeUntil(SingleSource<? extends E> other)
Returns a Single that emits the item emitted by the source Single until a second Single 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.
|
Observable<T> |
Observable.takeWhile(Predicate<? super T> predicate)
Returns an Observable that emits items emitted by the source ObservableSource so long as each item satisfied a
specified condition, and then completes as soon as this condition is not satisfied.
|
TestObserver<Void> |
Completable.test()
Creates a TestObserver and subscribes
it to this Completable.
|
TestObserver<T> |
Maybe.test()
Creates a TestObserver and subscribes
it to this Maybe.
|
TestSubscriber<T> |
Flowable.test()
Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes
it to this Flowable.
|
TestObserver<T> |
Single.test()
Creates a TestObserver and subscribes
it to this Single.
|
TestObserver<T> |
Observable.test()
Creates a TestObserver and subscribes
it to this Observable.
|
TestObserver<Void> |
Completable.test(boolean cancelled)
Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
|
TestObserver<T> |
Maybe.test(boolean cancelled)
Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.
|
TestObserver<T> |
Single.test(boolean cancelled)
Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.
|
TestObserver<T> |
Observable.test(boolean dispose)
Creates a TestObserver, optionally disposes it and then subscribes
it to this Observable.
|
TestSubscriber<T> |
Flowable.test(long initialRequest)
Creates a TestSubscriber with the given initial request amount and subscribes
it to this Flowable.
|
TestSubscriber<T> |
Flowable.test(long initialRequest,
boolean cancel)
Creates a TestSubscriber with the given initial request amount,
optionally cancels it before the subscription and subscribes
it to this Flowable.
|
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.
|
Observable<T> |
Observable.throttleFirst(long windowDuration,
TimeUnit unit)
Returns an Observable that emits only the first item emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.throttleFirst(long skipDuration,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits only the first item emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.throttleLast(long intervalDuration,
TimeUnit unit)
Returns an Observable that emits only the last item emitted by the source ObservableSource 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.
|
Observable<T> |
Observable.throttleLast(long intervalDuration,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits only the last item emitted by the source ObservableSource 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. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit,
boolean emitLast)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit,
boolean emitLast)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Flowable<T> |
Flowable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast)
Throttles items from the upstream
Flowable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
Observable<T> |
Observable.throttleLatest(long timeout,
TimeUnit unit,
Scheduler scheduler,
boolean emitLast)
Throttles items from the upstream
Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them. |
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.
|
Observable<T> |
Observable.throttleWithTimeout(long timeout,
TimeUnit unit)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the
source ObservableSource 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.
|
Observable<T> |
Observable.throttleWithTimeout(long timeout,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that mirrors the source ObservableSource, except that it drops items emitted by the
source ObservableSource 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.
|
Observable<Timed<T>> |
Observable.timeInterval()
Returns an Observable that emits records of the time interval between consecutive items emitted by the
source ObservableSource.
|
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.
|
Observable<Timed<T>> |
Observable.timeInterval(Scheduler scheduler)
Returns an Observable that emits records of the time interval between consecutive items emitted by the
source ObservableSource, 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.
|
Observable<Timed<T>> |
Observable.timeInterval(TimeUnit unit)
Returns an Observable that emits records of the time interval between consecutive items emitted by the
source ObservableSource.
|
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.
|
Observable<Timed<T>> |
Observable.timeInterval(TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits records of the time interval between consecutive items emitted by the
source ObservableSource, where this interval is computed on a specified Scheduler.
|
<V> Observable<T> |
Observable.timeout(Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator)
Returns an Observable that mirrors the source ObservableSource, but notifies observers of a
TimeoutException if an item emitted by the source ObservableSource doesn't arrive within a window of
time after the emission of the previous item, where that period of time is measured by an ObservableSource that
is a function of the previous item. |
<V> Observable<T> |
Observable.timeout(Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator,
ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource, but that switches to a fallback ObservableSource if
an item emitted by the source ObservableSource doesn't arrive within a window of time after the emission of the
previous item, where that period of time is measured by an ObservableSource that is a function of the previous
item.
|
<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.
|
Completable |
Completable.timeout(long timeout,
TimeUnit unit)
Returns a Completable that runs this Completable and emits a TimeoutException in case
this Completable doesn't complete within the given time.
|
Maybe<T> |
Maybe.timeout(long timeout,
TimeUnit timeUnit)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
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.
|
Single<T> |
Single.timeout(long timeout,
TimeUnit unit)
Signals a TimeoutException if the current Single doesn't signal a success value within the
specified timeout window.
|
Observable<T> |
Observable.timeout(long timeout,
TimeUnit timeUnit)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted
item.
|
Completable |
Completable.timeout(long timeout,
TimeUnit unit,
CompletableSource other)
Returns a Completable that runs this Completable and switches to the other Completable
in case this Completable doesn't complete within the given time.
|
Maybe<T> |
Maybe.timeout(long timeout,
TimeUnit timeUnit,
MaybeSource<? extends T> fallback)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item.
|
Observable<T> |
Observable.timeout(long timeout,
TimeUnit timeUnit,
ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource 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.
|
Completable |
Completable.timeout(long timeout,
TimeUnit unit,
Scheduler scheduler)
Returns a Completable that runs this Completable and emits a TimeoutException in case
this Completable doesn't complete within the given time while "waiting" on the specified
Scheduler.
|
Maybe<T> |
Maybe.timeout(long timeout,
TimeUnit timeUnit,
Scheduler scheduler)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item, where this policy is governed on a specified Scheduler.
|
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.
|
Single<T> |
Single.timeout(long timeout,
TimeUnit unit,
Scheduler scheduler)
Signals a TimeoutException if the current Single doesn't signal a success value within the
specified timeout window.
|
Observable<T> |
Observable.timeout(long timeout,
TimeUnit timeUnit,
Scheduler scheduler)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted
item, where this policy is governed on a specified Scheduler.
|
Completable |
Completable.timeout(long timeout,
TimeUnit unit,
Scheduler scheduler,
CompletableSource other)
Returns a Completable that runs this Completable and switches to the other Completable
in case this Completable doesn't complete within the given time while "waiting" on
the specified scheduler.
|
Maybe<T> |
Maybe.timeout(long timeout,
TimeUnit timeUnit,
Scheduler scheduler,
MaybeSource<? extends T> fallback)
Returns a Maybe that mirrors the source Maybe but applies a timeout policy for each emitted
item using a specified Scheduler.
|
Observable<T> |
Observable.timeout(long timeout,
TimeUnit timeUnit,
Scheduler scheduler,
ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource but applies a timeout policy for each emitted
item using 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.
|
Single<T> |
Single.timeout(long timeout,
TimeUnit unit,
Scheduler scheduler,
SingleSource<? extends T> other)
Runs the current Single and if it doesn't signal within the specified timeout window, it is
cancelled and the other SingleSource subscribed to.
|
Single<T> |
Single.timeout(long timeout,
TimeUnit unit,
SingleSource<? extends T> other)
Runs the current Single and if it doesn't signal within the specified timeout window, it is
cancelled and the other SingleSource subscribed to.
|
<U> Maybe<T> |
Maybe.timeout(MaybeSource<U> timeoutIndicator)
If the current
Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, a
TimeoutException is signaled instead. |
<U> Maybe<T> |
Maybe.timeout(MaybeSource<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current
Maybe didn't signal an event before the timeoutIndicator MaybeSource signals,
the current Maybe is cancelled and the fallback MaybeSource subscribed to
as a continuation. |
<U,V> Observable<T> |
Observable.timeout(ObservableSource<U> firstTimeoutIndicator,
Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator)
Returns an Observable that mirrors the source ObservableSource, but notifies observers of a
TimeoutException if either the first item emitted by the source ObservableSource or any subsequent item
doesn't arrive within time windows defined by other ObservableSources. |
<U,V> Observable<T> |
Observable.timeout(ObservableSource<U> firstTimeoutIndicator,
Function<? super T,? extends ObservableSource<V>> itemTimeoutIndicator,
ObservableSource<? extends T> other)
Returns an Observable that mirrors the source ObservableSource, but switches to a fallback ObservableSource if either
the first item emitted by the source ObservableSource or any subsequent item doesn't arrive within time windows
defined by other ObservableSources.
|
<U> Maybe<T> |
Maybe.timeout(org.reactivestreams.Publisher<U> timeoutIndicator)
If the current
Maybe source didn't signal an event before the timeoutIndicator Publisher signals, a
TimeoutException is signaled instead. |
<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.
|
<U> Maybe<T> |
Maybe.timeout(org.reactivestreams.Publisher<U> timeoutIndicator,
MaybeSource<? extends T> fallback)
If the current
Maybe didn't signal an event before the timeoutIndicator Publisher signals,
the current Maybe is cancelled and the fallback MaybeSource subscribed to
as a continuation. |
static Completable |
Completable.timer(long delay,
TimeUnit unit)
Returns a Completable instance that fires its onComplete event after the given delay elapsed.
|
static Maybe<Long> |
Maybe.timer(long delay,
TimeUnit unit)
Returns a Maybe that emits
0L after a specified delay. |
static Flowable<Long> |
Flowable.timer(long delay,
TimeUnit unit)
Returns a Flowable that emits
0L after a specified delay, and then completes. |
static Single<Long> |
Single.timer(long delay,
TimeUnit unit)
Signals success with 0L value after the given delay for each SingleObserver.
|
static Observable<Long> |
Observable.timer(long delay,
TimeUnit unit)
Returns an Observable that emits
0L after a specified delay, and then completes. |
static Completable |
Completable.timer(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Completable instance that fires its onComplete event after the given delay elapsed
by using the supplied scheduler.
|
static Maybe<Long> |
Maybe.timer(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns a Maybe that emits
0L after a specified delay on a specified Scheduler. |
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. |
static Single<Long> |
Single.timer(long delay,
TimeUnit unit,
Scheduler scheduler)
Signals success with 0L value after the given delay for each SingleObserver.
|
static Observable<Long> |
Observable.timer(long delay,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable 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. |
Observable<Timed<T>> |
Observable.timestamp()
Returns an Observable that emits each item emitted by the source ObservableSource, 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. |
Observable<Timed<T>> |
Observable.timestamp(Scheduler scheduler)
Returns an Observable that emits each item emitted by the source ObservableSource, 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. |
Observable<Timed<T>> |
Observable.timestamp(TimeUnit unit)
Returns an Observable that emits each item emitted by the source ObservableSource, 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. |
Observable<Timed<T>> |
Observable.timestamp(TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits each item emitted by the source ObservableSource, wrapped in a
Timed object whose timestamps are provided by a specified Scheduler. |
<U> U |
Completable.to(Function<? super Completable,U> converter)
Allows fluent conversion to another type via a function callback.
|
<R> R |
Flowable.to(Function<? super Flowable<T>,R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Maybe.to(Function<? super Maybe<T>,R> convert)
Calls the specified converter function with the current Maybe instance
during assembly time and returns its result.
|
<R> R |
Observable.to(Function<? super Observable<T>,R> converter)
Calls the specified converter function during assembly time and returns its resulting value.
|
<R> R |
Single.to(Function<? super Single<T>,R> convert)
Calls the specified converter function with the current Single instance
during assembly time and returns its result.
|
Completable |
Single.toCompletable()
Deprecated.
see
Single.ignoreElement() instead, will be removed in 3.0 |
Flowable<T> |
Maybe.toFlowable()
Converts this Maybe into a backpressure-aware Flowable instance composing cancellation
through.
|
Flowable<T> |
Single.toFlowable()
Converts this Single into a
Flowable . |
<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.
|
Future<T> |
Flowable.toFuture()
Returns a
Future representing the single value emitted by this Flowable . |
Future<T> |
Single.toFuture()
Returns a
Future representing the single value emitted by this Single . |
Future<T> |
Observable.toFuture()
Returns a
Future representing the single value emitted by this Observable . |
Single<List<T>> |
Flowable.toList()
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite upstream source Publisher.
|
Single<List<T>> |
Observable.toList()
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source ObservableSource.
|
<U extends Collection<? super T>> |
Flowable.toList(Callable<U> collectionSupplier)
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source Publisher.
|
<U extends Collection<? super T>> |
Observable.toList(Callable<U> collectionSupplier)
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source ObservableSource.
|
Single<List<T>> |
Flowable.toList(int capacityHint)
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source Publisher.
|
Single<List<T>> |
Observable.toList(int capacityHint)
Returns a Single that emits a single item, a list composed of all the items emitted by the
finite source ObservableSource.
|
<K> Single<Map<K,T>> |
Flowable.toMap(Function<? super T,? extends K> keySelector)
Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher,
mapped by the keys returned by a specified
keySelector function. |
<K> Single<Map<K,T>> |
Observable.toMap(Function<? super T,? extends K> keySelector)
Returns a Single that emits a single HashMap containing all items emitted by the
finite source ObservableSource, mapped by the keys returned by a specified
keySelector function. |
<K,V> Single<Map<K,V>> |
Flowable.toMap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the
finite source Publisher, mapped by the keys returned by a specified
keySelector function. |
<K,V> Single<Map<K,V>> |
Observable.toMap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
Returns a Single that emits a single HashMap containing values corresponding to items emitted by the
finite source ObservableSource, mapped by the keys returned by a specified
keySelector function. |
<K,V> Single<Map<K,V>> |
Flowable.toMap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
Callable<? extends Map<K,V>> mapSupplier)
Returns a Single that emits a single Map, returned by a specified
mapFactory function, that
contains keys and values extracted from the items emitted by the finite source Publisher. |
<K,V> Single<Map<K,V>> |
Observable.toMap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
Callable<? extends Map<K,V>> mapSupplier)
Returns a Single that emits a single Map, returned by a specified
mapFactory function, that
contains keys and values extracted from the items emitted by the finite source ObservableSource. |
Maybe<T> |
Single.toMaybe()
Converts this Single into a
Maybe . |
<T> Maybe<T> |
Completable.toMaybe()
Converts this Completable into a
Maybe . |
<K> Single<Map<K,Collection<T>>> |
Flowable.toMultimap(Function<? super T,? extends K> keySelector)
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the
finite source Publisher keyed by a specified
keySelector function. |
<K> Single<Map<K,Collection<T>>> |
Observable.toMultimap(Function<? super T,? extends K> keySelector)
Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the
finite source ObservableSource keyed by a specified
keySelector function. |
<K,V> Single<Map<K,Collection<V>>> |
Flowable.toMultimap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a
specified
valueSelector function from items emitted by the finite source Publisher, keyed by a
specified keySelector function. |
<K,V> Single<Map<K,Collection<V>>> |
Observable.toMultimap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a
specified
valueSelector function from items emitted by the finite source ObservableSource,
keyed by a specified keySelector function. |
<K,V> Single<Map<K,Collection<V>>> |
Flowable.toMultimap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
Callable<? extends Map<K,Collection<V>>> mapSupplier,
Function<? super K,? extends Collection<? super V>> collectionFactory)
Returns a Single that emits a single Map, returned by a specified
mapFactory function, that
contains a custom collection of values, extracted by a specified valueSelector function from
items emitted by the finite source Publisher, and keyed by the keySelector function. |
<K,V> Single<Map<K,Collection<V>>> |
Observable.toMultimap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
Callable<? extends Map<K,Collection<V>>> mapSupplier,
Function<? super K,? extends Collection<? super V>> collectionFactory)
Returns a Single that emits a single Map, returned by a specified
mapFactory function, that
contains a custom collection of values, extracted by a specified valueSelector function from
items emitted by the source ObservableSource, and keyed by the keySelector function. |
<K,V> Single<Map<K,Collection<V>>> |
Flowable.toMultimap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
Callable<Map<K,Collection<V>>> mapSupplier)
Returns a Single that emits a single Map, returned by a specified
mapFactory function, that
contains an ArrayList of values, extracted by a specified valueSelector function from items
emitted by the finite source Publisher and keyed by the keySelector function. |
<K,V> Single<Map<K,Collection<V>>> |
Observable.toMultimap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
Callable<Map<K,Collection<V>>> mapSupplier)
Returns a Single that emits a single Map, returned by a specified
mapFactory function, that
contains an ArrayList of values, extracted by a specified valueSelector function from items
emitted by the finite source ObservableSource and keyed by the keySelector function. |
Observable<T> |
Maybe.toObservable()
Converts this Maybe into an Observable instance composing cancellation
through.
|
Observable<T> |
Flowable.toObservable()
Converts the current Flowable into a non-backpressured
Observable . |
Observable<T> |
Single.toObservable()
Converts this Single into an
Observable . |
<T> Observable<T> |
Completable.toObservable()
Returns an Observable which when subscribed to subscribes to this Completable and
relays the terminal events to the subscriber.
|
Single<T> |
Maybe.toSingle()
Converts this Maybe into a Single instance composing cancellation
through and turning an empty Maybe into a signal of NoSuchElementException.
|
<T> Single<T> |
Completable.toSingle(Callable<? extends T> completionValueSupplier)
Converts this Completable into a Single which when this Completable completes normally,
calls the given supplier and emits its returned value through onSuccess.
|
Single<T> |
Maybe.toSingle(T defaultValue)
Converts this Maybe into a Single instance composing cancellation
through and turning an empty Maybe into a Single that emits the given
value through onSuccess.
|
<T> Single<T> |
Completable.toSingleDefault(T completionValue)
Converts this Completable into a Single which when this Completable completes normally,
emits the given value through onSuccess.
|
Single<List<T>> |
Flowable.toSortedList()
Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a
sorted order.
|
Single<List<T>> |
Observable.toSortedList()
Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a
sorted order.
|
Single<List<T>> |
Flowable.toSortedList(Comparator<? super T> comparator)
Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a
sorted order based on a specified comparison function.
|
Single<List<T>> |
Observable.toSortedList(Comparator<? super T> comparator)
Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a
sorted order based on a specified comparison function.
|
Single<List<T>> |
Flowable.toSortedList(Comparator<? super T> comparator,
int capacityHint)
Returns a Single that emits a list that contains the items emitted by the finite source Publisher, in a
sorted order based on a specified comparison function.
|
Single<List<T>> |
Observable.toSortedList(Comparator<? super T> comparator,
int capacityHint)
Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a
sorted order based on a specified comparison function.
|
Single<List<T>> |
Flowable.toSortedList(int capacityHint)
Returns a Flowable that emits a list that contains the items emitted by the finite source Publisher, in a
sorted order.
|
Single<List<T>> |
Observable.toSortedList(int capacityHint)
Returns a Single that emits a list that contains the items emitted by the finite source ObservableSource, in a
sorted order.
|
static Completable |
Completable.unsafeCreate(CompletableSource source)
Constructs a Completable instance by wrapping the given source callback
without any safeguards; you should manage the lifecycle and response
to downstream cancellation/dispose.
|
static <T> Maybe<T> |
Maybe.unsafeCreate(MaybeSource<T> onSubscribe)
Advanced use only: creates a Maybe instance without
any safeguards by using a callback that is called with a MaybeObserver.
|
static <T> Observable<T> |
Observable.unsafeCreate(ObservableSource<T> onSubscribe)
Create an Observable by wrapping an ObservableSource which has to be implemented according
to the Reactive-Streams-based Observable specification by handling
cancellation correctly; no safeguards are provided by the Observable itself.
|
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.
|
static <T> Single<T> |
Single.unsafeCreate(SingleSource<T> onSubscribe)
Advanced use only: creates a Single instance without
any safeguards by using a callback that is called with a SingleObserver.
|
Completable |
Completable.unsubscribeOn(Scheduler scheduler)
Returns a Completable which makes sure when a subscriber cancels the subscription, the
dispose is called on the specified scheduler.
|
Maybe<T> |
Maybe.unsubscribeOn(Scheduler scheduler)
Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable,
that call is propagated up on the specified scheduler.
|
Flowable<T> |
Flowable.unsubscribeOn(Scheduler scheduler)
Modifies the source Publisher so that subscribers will cancel it on a specified
Scheduler . |
Single<T> |
Single.unsubscribeOn(Scheduler scheduler)
Returns a Single which makes sure when a SingleObserver disposes the Disposable,
that call is propagated up on the specified scheduler.
|
Observable<T> |
Observable.unsubscribeOn(Scheduler scheduler)
Modifies the source ObservableSource so that subscribers will dispose it on a specified
Scheduler . |
static <T,D> Maybe<T> |
Maybe.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
Consumer<? super D> resourceDisposer)
Constructs a Maybe that creates a dependent resource object which is disposed of when the
upstream terminates or the downstream calls dispose().
|
static <T,D> Maybe<T> |
Maybe.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier,
Consumer<? super D> resourceDisposer,
boolean eager)
Constructs a Maybe that creates a dependent resource object which is disposed of just before
termination if you have set
disposeEagerly to true and a downstream dispose() does not occur
before termination. |
static <T,D> Observable<T> |
Observable.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier,
Consumer<? super D> disposer)
Constructs an ObservableSource that creates a dependent resource object which is disposed of when the downstream
calls dispose().
|
static <T,D> Observable<T> |
Observable.using(Callable<? extends D> resourceSupplier,
Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier,
Consumer<? super D> disposer,
boolean eager)
Constructs an ObservableSource that creates a dependent resource object which is disposed of just before
termination if you have set
disposeEagerly to true and a dispose() call does not occur
before termination. |
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. |
static <R> Completable |
Completable.using(Callable<R> resourceSupplier,
Function<? super R,? extends CompletableSource> completableFunction,
Consumer<? super R> disposer)
Returns a Completable instance which manages a resource along
with a custom Completable instance while the subscription is active.
|
static <R> Completable |
Completable.using(Callable<R> resourceSupplier,
Function<? super R,? extends CompletableSource> completableFunction,
Consumer<? super R> disposer,
boolean eager)
Returns a Completable instance which manages a resource along
with a custom Completable instance while the subscription is active and performs eager or lazy
resource disposition.
|
static <T,U> Single<T> |
Single.using(Callable<U> resourceSupplier,
Function<? super U,? extends SingleSource<? extends T>> singleFunction,
Consumer<? super U> disposer)
Allows using and disposing a resource while running a SingleSource instance generated from
that resource (similar to a try-with-resources).
|
static <T,U> Single<T> |
Single.using(Callable<U> resourceSupplier,
Function<? super U,? extends SingleSource<? extends T>> singleFunction,
Consumer<? super U> disposer,
boolean eager)
Allows using and disposing a resource while running a SingleSource instance generated from
that resource (similar to a try-with-resources).
|
<B> Observable<Observable<T>> |
Observable.window(Callable<? extends ObservableSource<B>> boundary)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
<B> Observable<Observable<T>> |
Observable.window(Callable<? extends ObservableSource<B>> boundary,
int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
<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.
|
Observable<Observable<T>> |
Observable.window(long count)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
Flowable<Flowable<T>> |
Flowable.window(long count,
long skip)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Observable<Observable<T>> |
Observable.window(long count,
long skip)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long count,
long skip,
int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
TimeUnit unit)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
TimeUnit unit,
Scheduler scheduler,
int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
Flowable<Flowable<T>> |
Flowable.window(long timespan,
TimeUnit unit)
Returns a Flowable that emits windows of items it collects from the source Publisher.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit,
long count)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit,
long count,
boolean restart)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit,
Scheduler scheduler)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count,
boolean restart)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
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.
|
Observable<Observable<T>> |
Observable.window(long timespan,
TimeUnit unit,
Scheduler scheduler,
long count,
boolean restart,
int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
<B> Observable<Observable<T>> |
Observable.window(ObservableSource<B> boundary)
Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource
where the boundary of each window is determined by the items emitted from a specified boundary-governing
ObservableSource.
|
<B> Observable<Observable<T>> |
Observable.window(ObservableSource<B> boundary,
int bufferSize)
Returns an Observable that emits non-overlapping windows of items it collects from the source ObservableSource
where the boundary of each window is determined by the items emitted from a specified boundary-governing
ObservableSource.
|
<U,V> Observable<Observable<T>> |
Observable.window(ObservableSource<U> openingIndicator,
Function<? super U,? extends ObservableSource<V>> closingIndicator)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
<U,V> Observable<Observable<T>> |
Observable.window(ObservableSource<U> openingIndicator,
Function<? super U,? extends ObservableSource<V>> closingIndicator,
int bufferSize)
Returns an Observable that emits windows of items it collects from the source ObservableSource.
|
<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> Observable<R> |
Observable.withLatestFrom(Iterable<? extends ObservableSource<?>> others,
Function<? super Object[],R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the
other ObservableSources via a function to produce the output item.
|
<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> Observable<R> |
Observable.withLatestFrom(ObservableSource<?>[] others,
Function<? super Object[],R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the
other ObservableSources via a function to produce the output item.
|
<U,R> Observable<R> |
Observable.withLatestFrom(ObservableSource<? extends U> other,
BiFunction<? super T,? super U,? extends R> combiner)
Merges the specified ObservableSource into this ObservableSource sequence by using the
resultSelector
function only when the source ObservableSource (this instance) emits an item. |
<T1,T2,R> Observable<R> |
Observable.withLatestFrom(ObservableSource<T1> o1,
ObservableSource<T2> o2,
Function3<? super T,? super T1,? super T2,R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the
other ObservableSources via a function to produce the output item.
|
<T1,T2,T3,R> |
Observable.withLatestFrom(ObservableSource<T1> o1,
ObservableSource<T2> o2,
ObservableSource<T3> o3,
Function4<? super T,? super T1,? super T2,? super T3,R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the
other ObservableSources via a function to produce the output item.
|
<T1,T2,T3,T4,R> |
Observable.withLatestFrom(ObservableSource<T1> o1,
ObservableSource<T2> o2,
ObservableSource<T3> o3,
ObservableSource<T4> o4,
Function5<? super T,? super T1,? super T2,? super T3,? super T4,R> combiner)
Combines the value emission from this ObservableSource with the latest emissions from the
other ObservableSources 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 Completable |
Completable.wrap(CompletableSource source)
Wraps the given CompletableSource into a Completable
if not already Completable.
|
static <T> Maybe<T> |
Maybe.wrap(MaybeSource<T> source)
Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe
instance.
|
static <T> Observable<T> |
Observable.wrap(ObservableSource<T> source)
Wraps an ObservableSource into an Observable if not already an Observable.
|
static <T> Single<T> |
Single.wrap(SingleSource<T> source)
Wraps a SingleSource instance into a new Single instance if not already a Single
instance.
|
static <T,R> Maybe<R> |
Maybe.zip(Iterable<? extends MaybeSource<? extends T>> sources,
Function<? super Object[],? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other MaybeSources.
|
static <T,R> Observable<R> |
Observable.zip(Iterable<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other ObservableSources.
|
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> Single<R> |
Single.zip(Iterable<? extends SingleSource<? extends T>> sources,
Function<? super Object[],? extends R> zipper)
Waits until all SingleSource sources provided by the Iterable sequence signal a success
value and calls a zipper function with an array of these values to return a result
to be emitted to downstream.
|
static <T1,T2,R> Maybe<R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other MaybeSources.
|
static <T1,T2,T3,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
three items emitted, in sequence, by three other MaybeSources.
|
static <T1,T2,T3,T4,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
four items emitted, in sequence, by four other MaybeSources.
|
static <T1,T2,T3,T4,T5,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
five items emitted, in sequence, by five other MaybeSources.
|
static <T1,T2,T3,T4,T5,T6,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
six items emitted, in sequence, by six other MaybeSources.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
MaybeSource<? extends T7> source7,
Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
seven items emitted, in sequence, by seven other MaybeSources.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
MaybeSource<? extends T7> source7,
MaybeSource<? extends T8> source8,
Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
eight items emitted, in sequence, by eight other MaybeSources.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Maybe.zip(MaybeSource<? extends T1> source1,
MaybeSource<? extends T2> source2,
MaybeSource<? extends T3> source3,
MaybeSource<? extends T4> source4,
MaybeSource<? extends T5> source5,
MaybeSource<? extends T6> source6,
MaybeSource<? extends T7> source7,
MaybeSource<? extends T8> source8,
MaybeSource<? extends T9> source9,
Function9<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? super T9,? extends R> zipper)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
nine items emitted, in sequence, by nine other MaybeSources.
|
static <T,R> Observable<R> |
Observable.zip(ObservableSource<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
n items emitted, in sequence, by the n ObservableSources emitted by a specified ObservableSource.
|
static <T1,T2,R> Observable<R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other ObservableSources.
|
static <T1,T2,R> Observable<R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper,
boolean delayError)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other ObservableSources.
|
static <T1,T2,R> Observable<R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper,
boolean delayError,
int bufferSize)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
two items emitted, in sequence, by two other ObservableSources.
|
static <T1,T2,T3,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
three items emitted, in sequence, by three other ObservableSources.
|
static <T1,T2,T3,T4,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
four items emitted, in sequence, by four other ObservableSources.
|
static <T1,T2,T3,T4,T5,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
five items emitted, in sequence, by five other ObservableSources.
|
static <T1,T2,T3,T4,T5,T6,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
six items emitted, in sequence, by six other ObservableSources.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
ObservableSource<? extends T7> source7,
Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
seven items emitted, in sequence, by seven other ObservableSources.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
ObservableSource<? extends T7> source7,
ObservableSource<? extends T8> source8,
Function8<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? super T8,? extends R> zipper)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
eight items emitted, in sequence, by eight other ObservableSources.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Observable.zip(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
ObservableSource<? extends T3> source3,
ObservableSource<? extends T4> source4,
ObservableSource<? extends T5> source5,
ObservableSource<? extends T6> source6,
ObservableSource<? extends T7> source7,
ObservableSource<? extends T8> source8,
ObservableSource<? 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 an Observable that emits the results of a specified combiner function applied to combinations of
nine items emitted, in sequence, by nine other ObservableSources.
|
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 <T1,T2,R> Single<R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
BiFunction<? super T1,? super T2,? extends R> zipper)
Returns a Single that emits the results of a specified combiner function applied to two items emitted by
two other Singles.
|
static <T1,T2,T3,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
Function3<? super T1,? super T2,? super T3,? extends R> zipper)
Returns a Single that emits the results of a specified combiner function applied to three items emitted
by three other Singles.
|
static <T1,T2,T3,T4,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
SingleSource<? extends T4> source4,
Function4<? super T1,? super T2,? super T3,? super T4,? extends R> zipper)
Returns a Single that emits the results of a specified combiner function applied to four items
emitted by four other Singles.
|
static <T1,T2,T3,T4,T5,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
SingleSource<? extends T4> source4,
SingleSource<? extends T5> source5,
Function5<? super T1,? super T2,? super T3,? super T4,? super T5,? extends R> zipper)
Returns a Single that emits the results of a specified combiner function applied to five items
emitted by five other Singles.
|
static <T1,T2,T3,T4,T5,T6,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
SingleSource<? extends T4> source4,
SingleSource<? extends T5> source5,
SingleSource<? extends T6> source6,
Function6<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? extends R> zipper)
Returns a Single that emits the results of a specified combiner function applied to six items
emitted by six other Singles.
|
static <T1,T2,T3,T4,T5,T6,T7,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
SingleSource<? extends T4> source4,
SingleSource<? extends T5> source5,
SingleSource<? extends T6> source6,
SingleSource<? extends T7> source7,
Function7<? super T1,? super T2,? super T3,? super T4,? super T5,? super T6,? super T7,? extends R> zipper)
Returns a Single that emits the results of a specified combiner function applied to seven items
emitted by seven other Singles.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
SingleSource<? extends T4> source4,
SingleSource<? extends T5> source5,
SingleSource<? extends T6> source6,
SingleSource<? extends T7> source7,
SingleSource<? 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 Single that emits the results of a specified combiner function applied to eight items
emitted by eight other Singles.
|
static <T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
Single.zip(SingleSource<? extends T1> source1,
SingleSource<? extends T2> source2,
SingleSource<? extends T3> source3,
SingleSource<? extends T4> source4,
SingleSource<? extends T5> source5,
SingleSource<? extends T6> source6,
SingleSource<? extends T7> source7,
SingleSource<? extends T8> source8,
SingleSource<? 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 Single that emits the results of a specified combiner function applied to nine items
emitted by nine other Singles.
|
static <T,R> Observable<R> |
Observable.zipArray(Function<? super Object[],? extends R> zipper,
boolean delayError,
int bufferSize,
ObservableSource<? extends T>... sources)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an array of other ObservableSources.
|
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> Maybe<R> |
Maybe.zipArray(Function<? super Object[],? extends R> zipper,
MaybeSource<? extends T>... sources)
Returns a Maybe that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an array of other MaybeSources.
|
static <T,R> Single<R> |
Single.zipArray(Function<? super Object[],? extends R> zipper,
SingleSource<? extends T>... sources)
Waits until all SingleSource sources provided via an array signal a success
value and calls a zipper function with an array of these values to return a result
to be emitted to downstream.
|
static <T,R> Observable<R> |
Observable.zipIterable(Iterable<? extends ObservableSource<? extends T>> sources,
Function<? super Object[],? extends R> zipper,
boolean delayError,
int bufferSize)
Returns an Observable that emits the results of a specified combiner function applied to combinations of
items emitted, in sequence, by an Iterable of other ObservableSources.
|
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> Observable<R> |
Observable.zipWith(Iterable<U> other,
BiFunction<? super T,? super U,? extends R> zipper)
Returns an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the source ObservableSource and a specified Iterable sequence.
|
<U,R> Maybe<R> |
Maybe.zipWith(MaybeSource<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper)
Waits until this and the other MaybeSource signal a success value then applies the given BiFunction
to those values and emits the BiFunction's resulting value to downstream.
|
<U,R> Observable<R> |
Observable.zipWith(ObservableSource<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper)
Returns an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the source ObservableSource and another specified ObservableSource.
|
<U,R> Observable<R> |
Observable.zipWith(ObservableSource<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper,
boolean delayError)
Returns an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the source ObservableSource and another specified ObservableSource.
|
<U,R> Observable<R> |
Observable.zipWith(ObservableSource<? extends U> other,
BiFunction<? super T,? super U,? extends R> zipper,
boolean delayError,
int bufferSize)
Returns an Observable that emits items that are the result of applying a specified function to pairs of
values, one each from the source ObservableSource and another specified ObservableSource.
|
<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.
|
<U,R> Single<R> |
Single.zipWith(SingleSource<U> other,
BiFunction<? super T,? super U,? extends R> zipper)
Returns a Single that emits the result of applying a specified function to the pair of items emitted by
the source Single and another specified Single.
|
Modifier and Type | Method and Description |
---|---|
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 |
---|---|
Observable<T> |
ConnectableObservable.refCount()
Returns an
Observable that stays connected to this ConnectableObservable as long as there
is at least one subscription to this ConnectableObservable . |
Observable<T> |
ConnectableObservable.refCount(int subscriberCount)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches the specified count and disconnect if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(int subscriberCount,
long timeout,
TimeUnit unit)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches the specified count and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(int subscriberCount,
long timeout,
TimeUnit unit,
Scheduler scheduler)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches the specified count and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(long timeout,
TimeUnit unit)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches 1 and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Observable<T> |
ConnectableObservable.refCount(long timeout,
TimeUnit unit,
Scheduler scheduler)
Connects to the upstream
ConnectableObservable if the number of subscribed
subscriber reaches 1 and disconnect after the specified
timeout if all subscribers have unsubscribed. |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Class and Description |
---|---|
class |
MulticastProcessor<T>
A
FlowableProcessor implementation that coordinates downstream requests through
a front-buffer and stable-prefetching, optionally canceling the upstream if all
subscribers have cancelled. |
Copyright © 2018 JBoss by Red Hat. All rights reserved.