@NonNull Flowable<java.util.List<T>> |
Flowable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits buffers of items it collects from the current Flowable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Flowable<U> |
Flowable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Supplier<@NonNull U> bufferSupplier) |
Returns a Flowable that emits buffers of items it collects from the current Flowable .
|
@NonNull Flowable<java.util.List<T>> |
Flowable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits buffers of items it collects from the current Flowable .
|
@NonNull Flowable<java.util.List<T>> |
Flowable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int count) |
Returns a Flowable that emits buffers of items it collects from the current Flowable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Flowable<U> |
Flowable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int count,
@NonNull Supplier<@NonNull U> bufferSupplier,
boolean restartTimerOnMaxSize) |
Returns a Flowable that emits buffers of items it collects from the current Flowable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Supplier<@NonNull U> bufferSupplier) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
@NonNull Observable<@NonNull java.util.List<T>> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int count) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull U extends java.util.Collection<? super @NonNull T>> @NonNull Observable<U> |
Observable.buffer(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int count,
@NonNull Supplier<@NonNull U> bufferSupplier,
boolean restartTimerOnMaxSize) |
Returns an Observable that emits buffers of items it collects from the current Observable .
|
<@NonNull R> @NonNull Flowable<R> |
Flowable.concatMap(@NonNull Function<? super @NonNull T,? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper,
int prefetch,
@NonNull Scheduler scheduler) |
Returns a new Flowable that emits items resulting from applying a function (on a designated scheduler)
that you supply to each item emitted by the current Flowable , where that function returns a Publisher , and then emitting the items
that result from concatenating those returned Publisher s.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
int bufferSize,
@NonNull Scheduler scheduler) |
Returns a new Observable that emits items resulting from applying a function that you supply to each item
emitted by the current Observable , where that function returns an ObservableSource , and then emitting the items
that result from concatenating those returned ObservableSource s.
|
<@NonNull R> @NonNull Flowable<R> |
Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper,
boolean tillTheEnd,
int prefetch,
@NonNull Scheduler scheduler) |
Maps each of the upstream items into a Publisher , subscribes to them one after the other,
one at a time and emits their values in order
while executing the mapper function on the designated scheduler, delaying any error from either this or any of the
inner Publisher s till all of them terminate.
|
<@NonNull R> @NonNull Observable<R> |
Observable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper,
boolean tillTheEnd,
int bufferSize,
@NonNull Scheduler scheduler) |
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 ObservableSource s
till all of them terminate.
|
@NonNull Flowable<T> |
Flowable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that mirrors the current Flowable , except that it drops items emitted by the
current Flowable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Flowable<T> |
Flowable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns a Flowable that mirrors the current Flowable , except that it drops items emitted by the
current Flowable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.debounce(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Completable |
Completable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Completable which delays the emission of the completion event by the given time while
running on the specified Scheduler .
|
@NonNull Completable |
Completable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 .
|
@NonNull Flowable<T> |
Flowable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a
specified delay.
|
@NonNull Flowable<T> |
Flowable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a
specified delay.
|
@NonNull Maybe<T> |
Maybe.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a
specified delay.
|
@NonNull Maybe<T> |
Maybe.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a
specified delay running on the specified Scheduler .
|
@NonNull Observable<T> |
Observable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a
specified delay.
|
@NonNull Observable<T> |
Observable.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a
specified delay.
|
@NonNull Single<T> |
Single.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Delays the emission of the success signal from the current Single by the specified amount.
|
@NonNull Single<T> |
Single.delay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Delays the emission of the success or error signal from the current Single by the specified amount.
|
@NonNull Completable |
Completable.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Completable that delays the subscription to the upstream by a given amount of time,
both waiting and subscribing on a given Scheduler .
|
@NonNull Flowable<T> |
Flowable.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that delays the subscription to the current Flowable by a given amount of time,
both waiting and subscribing on a given Scheduler .
|
@NonNull Maybe<T> |
Maybe.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Maybe that delays the subscription to the current Maybe by a given amount of time,
both waiting and subscribing on a given Scheduler .
|
@NonNull Observable<T> |
Observable.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that delays the subscription to the current Observable by a given amount of time,
both waiting and subscribing on a given Scheduler .
|
@NonNull Single<T> |
Single.delaySubscription(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Delays the actual subscription to the current Single until the given time delay elapsed.
|
static @NonNull Flowable<java.lang.Long> |
Flowable.interval(long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 @NonNull Flowable<java.lang.Long> |
Flowable.interval(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits a sequential number every specified interval of time, on a
specified Scheduler .
|
static @NonNull Observable<java.lang.Long> |
Observable.interval(long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 @NonNull Observable<java.lang.Long> |
Observable.interval(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits a sequential number every specified interval of time, on a
specified Scheduler .
|
static @NonNull Flowable<java.lang.Long> |
Flowable.intervalRange(long start,
long count,
long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Signals a range of long values, the first after some initial delay and the rest periodically after.
|
static @NonNull Observable<java.lang.Long> |
Observable.intervalRange(long start,
long count,
long initialDelay,
long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Signals a range of long values, the first after some initial delay and the rest periodically after.
|
@NonNull Completable |
Completable.observeOn(@NonNull Scheduler scheduler) |
Returns a Completable which emits the terminal events from the thread of the specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.observeOn(@NonNull Scheduler scheduler) |
Signals the items and terminal signals of the current Flowable on the specified Scheduler ,
asynchronously with a bounded buffer of Flowable.bufferSize() slots.
|
@NonNull Flowable<T> |
Flowable.observeOn(@NonNull Scheduler scheduler,
boolean delayError) |
Signals the items and terminal signals of the current Flowable on the specified Scheduler ,
asynchronously with a bounded buffer and optionally delays onError notifications.
|
@NonNull Flowable<T> |
Flowable.observeOn(@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Signals the items and terminal signals of the current Flowable on the specified Scheduler ,
asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
|
@NonNull Maybe<T> |
Maybe.observeOn(@NonNull Scheduler scheduler) |
Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler ,
asynchronously.
|
@NonNull Observable<T> |
Observable.observeOn(@NonNull Scheduler scheduler) |
Returns an Observable to perform the current Observable 's emissions and notifications on a specified Scheduler ,
asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".
|
@NonNull Observable<T> |
Observable.observeOn(@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable to perform the current Observable 's emissions and notifications on a specified Scheduler ,
asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.
|
@NonNull Observable<T> |
Observable.observeOn(@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable to perform the current Observable 's emissions and notifications on a specified Scheduler ,
asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
|
@NonNull Single<T> |
Single.observeOn(@NonNull Scheduler scheduler) |
Signals the success item or the terminal signals of the current Single on the specified Scheduler ,
asynchronously.
|
@NonNull ConnectableFlowable<T> |
Flowable.replay(int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and
replays a maximum of bufferSize items that are emitted within a specified time window to late Subscriber s.
|
@NonNull ConnectableFlowable<T> |
Flowable.replay(int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and
replays a maximum of bufferSize items that are emitted within a specified time window to late Subscriber s.
|
@NonNull ConnectableFlowable<T> |
Flowable.replay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and
replays all items emitted by it within a specified time window to late Subscriber s.
|
@NonNull ConnectableFlowable<T> |
Flowable.replay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
Returns a ConnectableFlowable that shares a single subscription to the current Flowable and
replays all items emitted by it within a specified time window to late Subscriber s.
|
<@NonNull R> @NonNull Flowable<R> |
Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,? extends org.reactivestreams.Publisher<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 current Flowable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Flowable<R> |
Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,? extends org.reactivestreams.Publisher<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
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 current Flowable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Flowable<R> |
Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,? extends org.reactivestreams.Publisher<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 current Flowable ,
replaying all items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Flowable<R> |
Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,? extends org.reactivestreams.Publisher<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
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 current Flowable ,
replaying all items that were emitted within a specified time window.
|
@NonNull ConnectableObservable<T> |
Observable.replay(int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a ConnectableObservable that shares a single subscription to the current Observable and
that replays a maximum of bufferSize items that are emitted within a specified time window.
|
@NonNull ConnectableObservable<T> |
Observable.replay(int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
Returns a ConnectableObservable that shares a single subscription to the current Observable and
that replays a maximum of bufferSize items that are emitted within a specified time window.
|
@NonNull ConnectableObservable<T> |
Observable.replay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a ConnectableObservable that shares a single subscription to the current Observable and
replays all items emitted by the current Observable within a specified time window.
|
@NonNull ConnectableObservable<T> |
Observable.replay(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
Returns a ConnectableObservable that shares a single subscription to the current Observable and
replays all items emitted by the current Observable within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 current Observable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
int bufferSize,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
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 current Observable ,
replaying no more than bufferSize items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 current Observable ,
replaying all items that were emitted within a specified time window.
|
<@NonNull R> @NonNull Observable<R> |
Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean eagerTruncate) |
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 current Observable ,
replaying all items that were emitted within a specified time window.
|
@NonNull Flowable<T> |
Flowable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable
within periodic time intervals, where the intervals are defined on a particular Scheduler .
|
@NonNull Flowable<T> |
Flowable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast) |
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable
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.
|
@NonNull Flowable<T> |
Flowable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable
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.
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals, where the intervals are defined on a particular Scheduler .
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
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.
|
@NonNull Observable<T> |
Observable.sample(long period,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable
within periodic time intervals, where the intervals are defined on a particular Scheduler .
|
@NonNull Flowable<T> |
Flowable.skip(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that skips values emitted by the current Flowable before a specified time window
on a specified Scheduler elapses.
|
@NonNull Observable<T> |
Observable.skip(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that skips values emitted by the current Observable before a specified time window
on a specified Scheduler elapses.
|
@NonNull Flowable<T> |
Flowable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that drops items emitted by the current Flowable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Flowable<T> |
Flowable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns a Flowable that drops items emitted by the current Flowable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Flowable<T> |
Flowable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns a Flowable that drops items emitted by the current Flowable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Observable<T> |
Observable.skipLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable that drops items emitted by the current Observable during a specified time window
(defined on a specified scheduler) before the source completes.
|
@NonNull Completable |
Completable.subscribeOn(@NonNull Scheduler scheduler) |
Returns a Completable which subscribes the downstream subscriber on the specified scheduler, making
sure the subscription side-effects happen on that specific thread of the Scheduler .
|
@NonNull Flowable<T> |
Flowable.subscribeOn(@NonNull Scheduler scheduler) |
Asynchronously subscribes Subscriber s to the current Flowable on the specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.subscribeOn(@NonNull Scheduler scheduler,
boolean requestOn) |
Asynchronously subscribes Subscriber s to the current Flowable on the specified Scheduler
optionally reroutes requests from other threads to the same Scheduler thread.
|
@NonNull Maybe<T> |
Maybe.subscribeOn(@NonNull Scheduler scheduler) |
Asynchronously subscribes subscribers to this Maybe on the specified Scheduler .
|
@NonNull Observable<T> |
Observable.subscribeOn(@NonNull Scheduler scheduler) |
Asynchronously subscribes Observer s to the current Observable on the specified Scheduler .
|
@NonNull Single<T> |
Single.subscribeOn(@NonNull Scheduler scheduler) |
|
@NonNull Flowable<T> |
Flowable.take(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a
specified Scheduler ) runs out.
|
@NonNull Observable<T> |
Observable.take(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits those items emitted by the current Observable before a specified time (on a
specified Scheduler ) runs out.
|
@NonNull Flowable<T> |
Flowable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits at most a specified number of items from the current Flowable that were
emitted in a specified window of time before the current Flowable completed, where the timing information is
provided by a given Scheduler .
|
@NonNull Flowable<T> |
Flowable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns a Flowable that emits at most a specified number of items from the current Flowable that were
emitted in a specified window of time before the current Flowable completed, where the timing information is
provided by a given Scheduler .
|
@NonNull Flowable<T> |
Flowable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified
window of time before the current Flowable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Flowable<T> |
Flowable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified
window of time before the current Flowable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Flowable<T> |
Flowable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns a Flowable that emits the items from the current Flowable that were emitted in a specified
window of time before the current Flowable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits at most a specified number of items from the current Observable that were
emitted in a specified window of time before the current Observable completed, where the timing information is
provided by a given Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long count,
long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable that emits at most a specified number of items from the current Observable that were
emitted in a specified window of time before the current Observable completed, where the timing information is
provided by a given Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.takeLast(long time,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean delayError,
int bufferSize) |
Returns an Observable that emits the items from the current Observable that were emitted in a specified
window of time before the current Observable completed, where the timing information is provided by a specified
Scheduler .
|
@NonNull Flowable<T> |
Flowable.throttleFirst(long skipDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits only the first item emitted by the current Flowable during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.throttleFirst(long skipDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns a Flowable that emits only the first item emitted by the current Flowable during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleFirst(long skipDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits only the first item emitted by the current Observable during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleFirst(long skipDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that emits only the first item emitted by the current Observable during sequential
time windows of a specified duration, where the windows are managed by a specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits only the last item emitted by the current Flowable during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns a Flowable that emits only the last item emitted by the current Flowable during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits only the last item emitted by the current Observable during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler .
|
@NonNull Observable<T> |
Observable.throttleLast(long intervalDuration,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that emits only the last item emitted by the current Observable during sequential
time windows of a specified duration, where the duration is governed by a specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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.
|
@NonNull Flowable<T> |
Flowable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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.
|
@NonNull Flowable<T> |
Flowable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast,
@NonNull Consumer<? super @NonNull T> onDropped) |
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, invoking the consumer for any dropped item.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them.
|
@NonNull Observable<T> |
Observable.throttleLatest(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
boolean emitLast,
@NonNull Consumer<? super @NonNull T> onDropped) |
Throttles items from the current Observable by first emitting the next
item from upstream, then periodically emitting the latest item (if any) when
the specified timeout elapses between them, invoking the consumer for any dropped item.
|
@NonNull Flowable<T> |
Flowable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that mirrors the current Flowable , except that it drops items emitted by the
current Flowable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Flowable<T> |
Flowable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns a Flowable that mirrors the current Flowable , except that it drops items emitted by the
current Flowable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Observable<T> |
Observable.throttleWithTimeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull Consumer<? super @NonNull T> onDropped) |
Returns an Observable that mirrors the current Observable , except that it drops items emitted by the
current Observable that are followed by newer items before a timeout value expires on a specified
Scheduler .
|
@NonNull Flowable<Timed<T>> |
Flowable.timeInterval(@NonNull Scheduler scheduler) |
Returns a Flowable that emits records of the time interval between consecutive items emitted by the
current Flowable , where this interval is computed on a specified Scheduler .
|
@NonNull Flowable<Timed<T>> |
Flowable.timeInterval(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits records of the time interval between consecutive items emitted by the
current Flowable , where this interval is computed on a specified Scheduler .
|
@NonNull Maybe<Timed<T>> |
Maybe.timeInterval(@NonNull Scheduler scheduler) |
Measures the time (in milliseconds) between the subscription and success item emission
of the current Maybe and signals it as a tuple ( Timed )
success value.
|
@NonNull Maybe<Timed<T>> |
Maybe.timeInterval(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Measures the time between the subscription and success item emission
of the current Maybe and signals it as a tuple ( Timed )
success value.
|
@NonNull Observable<Timed<T>> |
Observable.timeInterval(@NonNull Scheduler scheduler) |
Returns an Observable that emits records of the time interval between consecutive items emitted by the
current Observable , where this interval is computed on a specified Scheduler .
|
@NonNull Observable<Timed<T>> |
Observable.timeInterval(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits records of the time interval between consecutive items emitted by the
current Observable , where this interval is computed on a specified Scheduler .
|
@NonNull Single<Timed<T>> |
Single.timeInterval(@NonNull Scheduler scheduler) |
Measures the time (in milliseconds) between the subscription and success item emission
of the current Single and signals it as a tuple ( Timed )
success value.
|
@NonNull Single<Timed<T>> |
Single.timeInterval(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Measures the time between the subscription and success item emission
of the current Single and signals it as a tuple ( Timed )
success value.
|
@NonNull Completable |
Completable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull 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 .
|
@NonNull Completable |
Completable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull CompletableSource fallback) |
Returns a Completable that runs this Completable and switches to the other CompletableSource
in case this Completable doesn't complete within the given time while "waiting" on
the specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted
item, where this policy is governed by a specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback) |
Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted
item using a specified Scheduler .
|
@NonNull Maybe<T> |
Maybe.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted
item, where this policy is governed on a specified Scheduler .
|
@NonNull Maybe<T> |
Maybe.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull MaybeSource<? extends @NonNull T> fallback) |
Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted
item using a specified Scheduler .
|
@NonNull Observable<T> |
Observable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted
item, where this policy is governed on a specified Scheduler .
|
@NonNull Observable<T> |
Observable.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull ObservableSource<? extends @NonNull T> fallback) |
Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted
item using a specified Scheduler .
|
@NonNull Single<T> |
Single.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Signals a TimeoutException if the current Single doesn't signal a success value within the
specified timeout window.
|
@NonNull Single<T> |
Single.timeout(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
@NonNull SingleSource<? extends @NonNull T> fallback) |
Runs the current Single and if it doesn't signal within the specified timeout window, it is
disposed and the other SingleSource subscribed to.
|
private @NonNull Completable |
Completable.timeout0(long timeout,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler,
CompletableSource fallback) |
Returns a Completable that runs this Completable and optionally switches to the other CompletableSource
in case this Completable doesn't complete within the given time while "waiting" on
the specified Scheduler .
|
private Flowable<T> |
Flowable.timeout0(long timeout,
java.util.concurrent.TimeUnit unit,
org.reactivestreams.Publisher<? extends @NonNull T> fallback,
Scheduler scheduler) |
|
private @NonNull Observable<T> |
Observable.timeout0(long timeout,
@NonNull java.util.concurrent.TimeUnit unit,
@Nullable ObservableSource<? extends @NonNull T> fallback,
@NonNull Scheduler scheduler) |
|
private Single<T> |
Single.timeout0(long timeout,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler,
SingleSource<? extends @NonNull T> fallback) |
|
static @NonNull Completable |
Completable.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Completable instance that fires its onComplete event after the given delay elapsed
by using the supplied Scheduler .
|
static @NonNull Flowable<java.lang.Long> |
Flowable.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler , and then
completes.
|
static @NonNull Maybe<java.lang.Long> |
Maybe.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Maybe that emits 0L after a specified delay on a specified Scheduler .
|
static @NonNull Observable<java.lang.Long> |
Observable.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits 0L after a specified delay, on a specified Scheduler , and then
completes.
|
static @NonNull Single<java.lang.Long> |
Single.timer(long delay,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
|
@NonNull Flowable<Timed<T>> |
Flowable.timestamp(@NonNull Scheduler scheduler) |
Returns a Flowable that emits each item emitted by the current Flowable , wrapped in a
Timed object whose timestamps are provided by a specified Scheduler .
|
@NonNull Flowable<Timed<T>> |
Flowable.timestamp(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits each item emitted by the current Flowable , wrapped in a
Timed object whose timestamps are provided by a specified Scheduler .
|
@NonNull Maybe<Timed<T>> |
Maybe.timestamp(@NonNull Scheduler scheduler) |
Combines the success value from the current Maybe with the current time (in milliseconds) of
its reception, using the given Scheduler as time source,
then signals them as a Timed instance.
|
@NonNull Maybe<Timed<T>> |
Maybe.timestamp(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Combines the success value from the current Maybe with the current time of
its reception, using the given Scheduler as time source,
then signals it as a Timed instance.
|
@NonNull Observable<Timed<T>> |
Observable.timestamp(@NonNull Scheduler scheduler) |
Returns an Observable that emits each item emitted by the current Observable , wrapped in a
Timed object whose timestamps are provided by a specified Scheduler .
|
@NonNull Observable<Timed<T>> |
Observable.timestamp(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits each item emitted by the current Observable , wrapped in a
Timed object whose timestamps are provided by a specified Scheduler .
|
@NonNull Single<Timed<T>> |
Single.timestamp(@NonNull Scheduler scheduler) |
Combines the success value from the current Single with the current time (in milliseconds) of
its reception, using the given Scheduler as time source,
then signals them as a Timed instance.
|
@NonNull Single<Timed<T>> |
Single.timestamp(@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Combines the success value from the current Single with the current time of
its reception, using the given Scheduler as time source,
then signals it as a Timed instance.
|
@NonNull Completable |
Completable.unsubscribeOn(@NonNull Scheduler scheduler) |
Returns a Completable which makes sure when an observer disposes the subscription, the
dispose() method is called on the specified Scheduler .
|
@NonNull Flowable<T> |
Flowable.unsubscribeOn(@NonNull Scheduler scheduler) |
Cancels the current Flowable asynchronously by invoking Subscription.cancel()
on the specified Scheduler .
|
@NonNull Maybe<T> |
Maybe.unsubscribeOn(@NonNull Scheduler scheduler) |
|
@NonNull Observable<T> |
Observable.unsubscribeOn(@NonNull Scheduler scheduler) |
Return an Observable that schedules the downstream Observer s' dispose calls
aimed at the current Observable on the given Scheduler .
|
@NonNull Single<T> |
Single.unsubscribeOn(@NonNull Scheduler scheduler) |
|
@NonNull Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits windows of items it collects from the current Flowable .
|
@NonNull Flowable<Flowable<T>> |
Flowable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int bufferSize) |
Returns a Flowable that emits windows of items it collects from the current Flowable .
|
@NonNull Flowable<Flowable<T>> |
Flowable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns a Flowable that emits windows of items it collects from the current Flowable .
|
@NonNull Flowable<Flowable<T>> |
Flowable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count) |
Returns a Flowable that emits windows of items it collects from the current Flowable .
|
@NonNull Flowable<Flowable<T>> |
Flowable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count,
boolean restart) |
Returns a Flowable that emits windows of items it collects from the current Flowable .
|
@NonNull Flowable<Flowable<T>> |
Flowable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count,
boolean restart,
int bufferSize) |
Returns a Flowable that emits windows of items it collects from the current Flowable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
long timeskip,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
int bufferSize) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count,
boolean restart) |
Returns an Observable that emits windows of items it collects from the current Observable .
|
@NonNull Observable<Observable<T>> |
Observable.window(long timespan,
@NonNull java.util.concurrent.TimeUnit unit,
@NonNull Scheduler scheduler,
long count,
boolean restart,
int bufferSize) |
Returns an Observable that emits windows of items it collects from the current Observable .
|