An Observable wrapping the source one that will invokes the given action when it receives a request for more items.
An Observable wrapping the source one that will invokes the given action when it receives a request for more items.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
the action that gets called when an Observer requests items from this Observable
an Observable that will call onRequest when appropriate
(Since version 0.25.0) Use Observable.doOnRequest instead. This is kept here only for backward compatibility.
Returns an Observable that applies a function to each item emitted or notification raised by the source Observable and then flattens the Observable s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Observables.
Returns an Observable that applies a function to each item emitted or notification raised by the source Observable and then flattens the Observable s returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Observables.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
a function that returns an Observable to merge for each item emitted by the source Observable
a function that returns an Observable to merge for an onError notification from the source Observable
a function that returns an Observable to merge for an onCompleted notification from the source Observable
the maximum number of Observables that may be subscribed to concurrently
an Observable that emits the results of merging the Observables returned from applying the specified functions to the emissions and notifications of the source Observable
(Since version 0.25.0) Use Observable.flatMap[R](maxConcurrent:Int,onNext:T=>rx\.lang\.scala\.Observable[R],onError:Throwable=>rx\.lang\.scala\.Observable[R],onCompleted:()=>rx\.lang\.scala\.Observable[R])* instead. This is kept here only for backward compatibility.
Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable , where that function returns an Observable , and then merging those resulting Observables and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Observables.
Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable , where that function returns an Observable , and then merging those resulting Observables and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Observables.
$$noDefaultScheduler
a function that, when applied to an item emitted by the source Observable, returns an Observable
the maximum number of Observables that may be subscribed to concurrently
an Observable that emits the result of applying the transformation function to each item emitted by the source Observable and merging the results of the Observables obtained from this transformation
(Since version 0.25.0) Use Observable.flatMap[R](maxConcurrent:Int,f:T=>rx\.lang\.scala\.Observable[R])* instead. This is kept here only for backward compatibility.
Instructs an Observable will block the producer thread if the source emits items faster than its Observer can consume them
Instructs an Observable will block the producer thread if the source emits items faster than its Observer can consume them
The producer side can emit up to the system-wide ring buffer size onNext elements without blocking, but
the consumer side considers the amount its downstream requested through Producer.request(n)
and doesn't emit more than requested even if available.
Note that if the upstream Observable does support backpressure, this operator ignores that capability and doesn't propagate any backpressure requests from downstream.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
an Observable that will block the producer thread if the source emits items faster than its Observer can consume them
(Since version 0.25.0) Use Observable.onBackpressureBlock:* instead. This is kept here only for backward compatibility.
Instructs an Observable will block the producer thread if the source emits items faster than its Observer can consume them
Instructs an Observable will block the producer thread if the source emits items faster than its Observer can consume them
The producer side can emit up to maxQueueLength onNext elements without blocking, but the
consumer side considers the amount its downstream requested through Producer.request(n)
and doesn't emit more than requested even if more is available. For example, using
onBackpressureBlock(384).observeOn(Schedulers.io()) will not throw a MissingBackpressureException.
Note that if the upstream Observable does support backpressure, this operator ignores that capability and doesn't propagate any backpressure requests from downstream.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
the maximum number of items the producer can emit without blocking
an Observable that will block the producer thread if the source emits items faster than its Observer can consume them
(Since version 0.25.0) Use Observable.onBackpressureBlock(maxQueueLength:Int)* instead. This is kept here only for backward compatibility.
Instructs an Observable that is emitting items faster than its Observer can consume them to buffer up to a given amount of items until they can be emitted.
Instructs an Observable that is emitting items faster than its Observer can consume them to buffer up to
a given amount of items until they can be emitted. The resulting Observable will emit
BufferOverflowException as soon as the buffer's capacity is exceeded, drop all undelivered
items, unsubscribe from the source, and notify onOverflow.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
capacity of the internal buffer.
an action to run when the buffer's capacity is exceeded. This is a by-name parameter.
the source Observable modified to buffer items up to the given capacity
(Since version 0.25.0) Use Observable.onBackpressureBuffer(capacity:Long,onOverflow:=>Unit)* instead. This is kept here only for backward compatibility.
(if this graduates from Experimental/Beta to supported, replace this parenthetical with the release number)
Instructs an Observable that is emitting items faster than its Observer can consume them to buffer up to a given amount of items until they can be emitted.
Instructs an Observable that is emitting items faster than its Observer can consume them to buffer up to
a given amount of items until they can be emitted. The resulting Observable will emit
BufferOverflowException as soon as the buffer's capacity is exceeded, drop all undelivered
items, and unsubscribe from the source.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
capacity of the internal buffer.
an Observable that will buffer items up to the given capacity
(Since version 0.25.0) Use Observable.onBackpressureBuffer(capacity:Long)* instead. This is kept here only for backward compatibility.
Instructs an Observable that is emitting items faster than its observer can consume them to discard, rather than emit, those items that its observer is not prepared to observe.
Instructs an Observable that is emitting items faster than its observer can consume them to discard, rather than emit, those items that its observer is not prepared to observe.
If the downstream request count hits 0 then the Observable will refrain from calling onNext until
the observer invokes request(n) again to increase the request count.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
the action to invoke for each item dropped. onDrop action should be fast and should never block.
an new Observable that will drop onNext notifications on overflow
(Since version 0.25.0) Use Observable.onBackpressureDrop(onDrop:T=>Unit)* instead. This is kept here only for backward compatibility.
Returns an Observable that emits the items emitted by the source Observable or the items of an alternate Observable if the source Observable is empty.
Returns an Observable that emits the items emitted by the source Observable or the items of an alternate Observable if the source Observable is empty.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
the alternate Observable to subscribe to if the source does not emit any items
an Observable that emits the items emitted by the source Observable or the items of an alternate Observable if the source Observable is empty.
(Since version 0.25.0) Use Observable.switchIfEmpty instead. This is kept here only for backward compatibility.
Returns an Observable that emits items emitted by the source Observable, checks the specified predicate for each item, and then completes if the condition is satisfied.
Returns an Observable that emits items emitted by the source Observable, checks the specified predicate for each item, and then completes if the condition is satisfied.
The difference between this operator and takeWhile(T => Boolean) is that here, the condition is
evaluated after the item is emitted.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
a function that evaluates an item emitted by the source Observable and returns a Boolean
an Observable that first emits items emitted by the source Observable, checks the specified condition after each item, and then completes if the condition is satisfied.
(Since version 0.25.0) Use Observable.takeUntil(stopPredicate:T=>Boolean)* instead. This is kept here only for backward compatibility.
Merges the specified Observable into this Observable sequence by using the resultSelector
function only when the source Observable (this instance) emits an item.
Merges the specified Observable into this Observable sequence by using the resultSelector
function only when the source Observable (this instance) emits an item.
This method does not operate by default on a particular Scheduler.
A class to add Experimental/Beta APIs in RxJava. These APIs can change at any time.
import rx.lang.scala.ExperimentalAPIs._ to enable them.
the other Observable
the function to call when this Observable emits an item and the other Observable has already emitted an item, to generate the item to be emitted by the resulting Observable
an Observable that merges the specified Observable into this Observable by using the
resultSelector function only when the source Observable sequence (this instance) emits an item
(Since version 0.25.0) Use Observable.withLatestFrom instead. This is kept here only for backward compatibility.
(Since version 0.25.0) Use new methods in Observable instead. This is kept here only for backward compatibility.