Concatenates the source with another observable.
Concatenates the source with another observable.
Ordering of subscription is preserved, so the second observable
starts only after the source observable is completed
successfully with an onComplete. On the other hand, the second
observable is never subscribed if the source completes with an
error.
Creates a new Observable that emits the given element and then it also emits the events of the source (prepend operation).
Creates a new Observable that emits the given element and then it also emits the events of the source (prepend operation).
Creates a new Observable that emits the events of the source and then it also emits the given element (appended to the stream).
Creates a new Observable that emits the events of the source and then it also emits the given element (appended to the stream).
Given the source observable and another Observable, emits all of
the items from the first of these Observables to emit an item
and cancel the other.
Given the source observable and another Observable, emits all of
the items from the first of these Observables to emit an item
and cancel the other.
Returns the first generated result as a
CancelableFuture, returning
an Option because the source can be empty.
Returns the first generated result as a
CancelableFuture, returning
an Option because the source can be empty.
Creates a new Task that upon execution will signal the first generated element of the source observable and then it will stop the stream.
Creates a new Task that upon execution
will signal the first generated element of the source observable
and then it will stop the stream. Returns an Option because
the source can be empty.
Forces a buffered asynchronous boundary.
Forces a buffered asynchronous boundary.
Internally it wraps the observer implementation given to
onSubscribe into a
BufferedSubscriber.
Normally Monix's implementation guarantees that events are
not emitted concurrently, and that the publisher MUST NOT
emit the next event without acknowledgement from the
consumer that it may proceed, however for badly behaved
publishers, this wrapper provides the guarantee that the
downstream Observer given in
subscribe will not receive concurrent events.
WARNING: if the buffer created by this operator is unbounded, it can blow up the process if the data source is pushing events faster than what the observer can consume, as it introduces an asynchronous boundary that eliminates the back-pressure requirements of the data source. Unbounded is the default overflowStrategy, see OverflowStrategy for options.
- the overflow strategy used for buffering, which specifies what to do in case we're dealing with a slow consumer - should an unbounded buffer be used, should back-pressure be applied, should the pipeline drop newer or older events, should it drop the whole buffer? See OverflowStrategy for more details.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers). The underlying subject used is a BehaviorSubject.
Returns an observable that emits buffers of items it collects from the source observable.
Returns an observable that emits buffers of items it collects from
the source observable. The resulting observable emits buffers
every skip items, each containing count items.
If the source observable completes, then the current buffer gets signaled downstream. If the source triggers an error then the current buffer is being dropped and the error gets propagated immediately.
For count and skip there are 3 possibilities:
skip == count, then there are no items dropped and
no overlap, the call being equivalent to buffer(count)
2. in case skip < count, then overlap between buffers
happens, with the number of elements being repeated being
count - skip
3. in case skip > count, then skip - count elements start
getting dropped between windows
the maximum size of each buffer before it should be emitted
how many items emitted by the source observable should
be skipped before starting a new buffer. Note that when
skip and count are equal, this is the same operation as
buffer(count)
Periodically gather items emitted by an observable into bundles and emit these bundles rather than emitting the items one at a time.
Periodically gather items emitted by an observable into bundles
and emit these bundles rather than emitting the items one at a
time. This version of buffer is emitting items once the
internal buffer has reached the given count.
If the source observable completes, then the current buffer gets signaled downstream. If the source triggers an error then the current buffer is being dropped and the error gets propagated immediately.
the maximum size of each buffer before it should be emitted
Periodically gather items emitted by an observable into bundles and emit these bundles rather than emitting the items one at a time.
Periodically gather items emitted by an observable into bundles and emit these bundles rather than emitting the items one at a time.
The resulting observable emits connected, non-overlapping
buffers, each of a fixed duration specified by the timespan
argument or a maximum size specified by the maxSize argument
(whichever is reached first).
If the source observable completes, then the current buffer gets signaled downstream. If the source triggers an error then the current buffer is being dropped and the error gets propagated immediately.
the interval of time at which it should emit the buffered bundle
is the maximum bundle size
Periodically gather items emitted by an observable into bundles and emit these bundles rather than emitting the items one at a time.
Periodically gather items emitted by an observable into bundles and emit these bundles rather than emitting the items one at a time.
This version of buffer emits a new bundle of items
periodically, every timespan amount of time, containing all
items emitted by the source Observable since the previous bundle
emission.
If the source observable completes, then the current buffer gets signaled downstream. If the source triggers an error then the current buffer is being dropped and the error gets propagated immediately.
the interval of time at which it should emit the buffered bundle
Caches the emissions from the source Observable and replays them in order to any subsequent Subscribers.
Caches the emissions from the source Observable and replays them in order to any subsequent Subscribers. This operator has similar behavior to replay except that this auto-subscribes to the source Observable rather than returning a ConnectableObservable for which you must call connect to activate the subscription.
When you call cache, it does not yet subscribe to the source
Observable and so does not yet begin caching items. This only
happens when the first Subscriber calls the resulting
Observable's subscribe method.
is the maximum buffer size after which old events start being dropped (according to what happens when using ReplaySubject.createWithSize)
an Observable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
Caches the emissions from the source Observable and replays them in order to any subsequent Subscribers.
Caches the emissions from the source Observable and replays them in order to any subsequent Subscribers. This operator has similar behavior to replay except that this auto-subscribes to the source Observable rather than returning a ConnectableObservable for which you must call connect to activate the subscription.
When you call cache, it does not yet subscribe to the source
Observable and so does not yet begin caching items. This only
happens when the first Subscriber calls the resulting
Observable's subscribe method.
Note: You sacrifice the ability to cancel the origin when you use the cache operator so be careful not to use this on Observables that emit an infinite or very large number of items that will use up memory.
an Observable that, when first subscribed to, caches all of its items and notifications for the benefit of subsequent subscribers
Applies the given partial function to the source for each element for which the given partial function is defined.
Applies the given partial function to the source for each element for which the given partial function is defined.
the function that filters and maps the source
an observable that emits the transformed items by the given partial function
Creates a new observable from the source and another given observable, by emitting elements combined in pairs.
Creates a new observable from the source and another given observable, by emitting elements combined in pairs. If one of the observables emits fewer events than the other, then the rest of the unpaired events are ignored.
See zip for an alternative that pairs the items in strict sequence.
is an observable that gets paired with the source
Creates a new observable from the source and another given observable, by emitting elements combined in pairs.
Creates a new observable from the source and another given observable, by emitting elements combined in pairs. If one of the observables emits fewer events than the other, then the rest of the unpaired events are ignored.
See zipWith for an alternative that pairs the items in strict sequence.
is an observable that gets paired with the source
is a mapping function over the generated pairs
Ignores all items emitted by the source Observable and only calls onCompleted or onError.
Ignores all items emitted by the source Observable and only calls onCompleted or onError.
an empty Observable that only calls onCompleted or onError, based on which one is called by the source Observable
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
You can combine the items emitted by multiple observables so that they act like a single sequence by using this operator.
The difference between the concat operation
and mergeis that concat cares about the ordering of sequences
(e.g. all items emitted by the first observable in the sequence
will come before the elements emitted by the second observable),
whereas merge doesn't care about that (elements get
emitted as they come). Because of back-pressure applied to
observables, concat is safe to use in all contexts, whereas
merge requires buffering.
an observable that emits items that are the result of flattening the items emitted by the observables emitted by the source
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
You can combine the items emitted by multiple observables so that they act like a single sequence by using this operator.
The difference between the concat operation
and mergeis that concat cares about the ordering of sequences
(e.g. all items emitted by the first observable in the sequence
will come before the elements emitted by the second observable),
whereas merge doesn't care about that (elements get
emitted as they come). Because of back-pressure applied to
observables, concat is safe to use in all contexts, whereas
merge requires buffering.
This version is reserving onError notifications until all of the observables complete and only then passing the issued errors(s) downstream. Note that the streamed error is a CompositeException, since multiple errors from multiple streams can happen.
an observable that emits items that are the result of flattening the items emitted by the observables emitted by the source
Applies a function that you supply to each item emitted by the source observable, where that function returns observables, and then concatenating those resulting sequences and emitting the results of this concatenation.
Applies a function that you supply to each item emitted by the source observable, where that function returns observables, and then concatenating those resulting sequences and emitting the results of this concatenation.
The difference between the concat operation
and mergeis that concat cares about the ordering of sequences
(e.g. all items emitted by the first observable in the sequence
will come before the elements emitted by the second observable),
whereas merge doesn't care about that (elements get
emitted as they come). Because of back-pressure applied to
observables, concat is safe to use in all contexts, whereas
merge requires buffering.
Applies a function that you supply to each item emitted by the source observable, where that function returns sequences and then concatenating those resulting sequences and emitting the results of this concatenation.
Applies a function that you supply to each item emitted by the source observable, where that function returns sequences and then concatenating those resulting sequences and emitting the results of this concatenation.
This version is reserving onError notifications until all of the observables complete and only then passing the issued errors(s) downstream. Note that the streamed error is a CompositeException, since multiple errors from multiple streams can happen.
a function that, when applied to an item emitted by the source, returns an observable
an observable that emits items that are the result of flattening the items emitted by the observables emitted by the source
Creates a new Observable that emits the total number of onNext
events that were emitted by the source.
Creates a new Observable that emits the total number of onNext
events that were emitted by the source.
Note that this Observable emits only one item after the source is complete. And in case the source emits an error, then only that error will be emitted.
Only emit an item from an observable if a particular timespan has passed without it emitting another item.
Only emit an item from an observable if a particular timespan has passed without it emitting another item.
Note: If the source observable keeps emitting items more frequently than the length of the time window, then no items will be emitted by the resulting observable.
the length of the window of time that must pass after the emission of an item from the source observable in which that observable emits no items in order for the item to be emitted by the resulting observable
echoOnce for a similar operator that also mirrors the source observable
Emits the last item from the source Observable if a particular timespan has passed without it emitting another item, and keeps emitting that item at regular intervals until the source breaks the silence.
Emits the last item from the source Observable if a particular timespan has passed without it emitting another item, and keeps emitting that item at regular intervals until the source breaks the silence.
So compared to regular debounceTo this version keeps emitting the last item of the source.
Note: If the source Observable keeps emitting items more frequently than the length of the time window then no items will be emitted by the resulting Observable.
the length of the window of time that must pass after the emission of an item from the source Observable in which that Observable emits no items in order for the item to be emitted by the resulting Observable at regular intervals, also determined by period
echoRepeated for a similar operator that also mirrors the source observable
Doesn't emit anything until a timeout period passes without the
source emitting anything.
Doesn't emit anything until a timeout period passes without the
source emitting anything. When that timeout happens, we
subscribe to the observable generated by the given function, an
observable that will keep emitting until the source will break
the silence by emitting another event.
Note: If the source observable keeps emitting items more frequently than the length of the time window, then no items will be emitted by the resulting Observable.
the length of the window of time that must pass after the emission of an item from the source Observable in which that Observable emits no items in order for the item to be emitted by the resulting Observable
is a function that receives the last element generated by the source, generating an observable to be subscribed when the source is timing out
Emit items from the source, or emit a default item if the source completes after emitting no items.
Emit items from the source, or emit a default item if the source completes after emitting no items.
Delays emitting the final onComplete event by the specified amount.
Delays emitting the final onComplete event by the specified amount.
Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a specified delay.
Returns an Observable that emits the items emitted by the source Observable shifted forward in time by a specified delay.
Each time the source Observable emits an item, delay starts a timer, and when that timer reaches the given duration, the Observable returned from delay emits the same item.
NOTE: this delay refers strictly to the time between the
onNext event coming from our source and the time it takes the
downstream observer to get this event. On the other hand the
operator is also applying back-pressure, so on slow observers
the actual time passing between two successive events may be
higher than the specified duration.
- the delay to shift the source by
the source Observable shifted in time by the specified delay
Returns an Observable that emits the items emitted by the source Observable shifted forward in time.
Returns an Observable that emits the items emitted by the source Observable shifted forward in time.
This variant of delay sets its delay duration on a per-item
basis by passing each item from the source Observable into a
function that returns an Observable and then monitoring those
Observables. When any such Observable emits an item or
completes, the Observable returned by delay emits the associated
item.
is a function that returns an Observable for
each item emitted by the source Observable, which is then
used to delay the emission of that item by the resulting
Observable until the Observable returned from selector
emits an item
the source Observable shifted in time by the specified delay
Hold an Observer's subscription request for a specified amount of time before passing it on to the source Observable.
Hold an Observer's subscription request for a specified amount of time before passing it on to the source Observable.
is the time to wait before the subscription is being initiated.
Hold an Observer's subscription request until the given trigger
observable either emits an item or completes, before passing it
on to the source Observable.
Hold an Observer's subscription request until the given trigger
observable either emits an item or completes, before passing it
on to the source Observable.
If the given trigger completes in error, then the subscription is
terminated with onError.
the observable that must either emit an item or complete in order for the source to be subscribed.
Converts the source Observable that emits Notification[A] (the
result of materialize) back to an Observable that emits A.
Converts the source Observable that emits Notification[A] (the
result of materialize) back to an Observable that emits A.
Suppress the duplicate elements emitted by the source Observable.
Suppress the duplicate elements emitted by the source Observable.
WARNING: this requires unbounded buffering.
Given a function that returns a key for each element emitted by the source Observable, suppress duplicates items.
Given a function that returns a key for each element emitted by the source Observable, suppress duplicates items.
WARNING: this requires unbounded buffering.
Suppress duplicate consecutive items emitted by the source Observable
Suppress duplicate consecutive items emitted by the source Observable
Suppress duplicate consecutive items emitted by the source Observable
Suppress duplicate consecutive items emitted by the source Observable
Executes the given callback if the downstream observer has
canceled the streaming by returning Cancel as a result of onNext.
Executes the given callback if the downstream observer has
canceled the streaming by returning Cancel as a result of onNext.
Executes the given callback when the stream has ended, but before the complete event is emitted.
Executes the given callback when the stream has ended, but before the complete event is emitted.
the callback to execute when the subscription is canceled
Executes the given callback when the stream is interrupted with an
error, before the onError event is emitted downstream.
Executes the given callback when the stream is interrupted with an
error, before the onError event is emitted downstream.
NOTE: should protect the code in this callback, because if it
throws an exception the onError event will prefer signaling
the original exception and otherwise the behavior is undefined.
Executes the given callback for each element generated by the source Observable, useful for doing side-effects.
Executes the given callback for each element generated by the source Observable, useful for doing side-effects.
a new Observable that executes the specified callback for each element
Executes the given callback only for the first element generated by the source Observable, useful for doing a piece of computation only when the stream starts.
Executes the given callback only for the first element generated by the source Observable, useful for doing a piece of computation only when the stream starts.
a new Observable that executes the specified callback only for the first element
Executes the given callback before the subscription happens.
Executes the given callback before the subscription happens.
Drops the first n elements (from the start).
Drops the first n elements (from the start).
the number of elements to drop
a new Observable that drops the first n elements emitted by the source
Creates a new observable that drops the events of the source, only
for the specified timestamp window.
Creates a new observable that drops the events of the source, only
for the specified timestamp window.
the window of time during which the new observable must drop events emitted by the source
Drops the last n elements (from the end).
Drops the last n elements (from the end).
the number of elements to drop
a new Observable that drops the first n elements emitted by the source
Discard items emitted by the source until a second observable emits an item or completes.
Discard items emitted by the source until a second observable emits an item or completes.
If the trigger observable completes in error, then the
resulting observable will also end in error when it notices
it (next time an element is emitted by the source).
the observable that has to emit an item before the source begin to be mirrored by the resulting observable
Drops the longest prefix of elements that satisfy the given predicate and returns a new observable that emits the rest.
Drops the longest prefix of elements that satisfy the given predicate and returns a new observable that emits the rest.
Drops the longest prefix of elements that satisfy the given function and returns a new observable that emits the rest.
Drops the longest prefix of elements that satisfy the given function and returns a new observable that emits the rest. In comparison with dropWhile, this version accepts a function that takes an additional parameter: the zero-based index of the element.
Utility that can be used for debugging purposes.
Utility that can be used for debugging purposes.
Mirror the source observable as long as the source keeps emitting
items, otherwise if timeout passes without the source emitting
anything new then the observable will emit the last item.
Mirror the source observable as long as the source keeps emitting
items, otherwise if timeout passes without the source emitting
anything new then the observable will emit the last item.
This is the rough equivalent of:
Observable.merge(source, source.debounce(period))
Note: If the source Observable keeps emitting items more frequently than the length of the time window then the resulting observable will mirror the source exactly.
the window of silence that must pass in order for the observable to echo the last item
Mirror the source observable as long as the source keeps emitting
items, otherwise if timeout passes without the source emitting
anything new then the observable will start emitting the last
item repeatedly.
Mirror the source observable as long as the source keeps emitting
items, otherwise if timeout passes without the source emitting
anything new then the observable will start emitting the last
item repeatedly.
Note: If the source Observable keeps emitting items more frequently than the length of the time window then the resulting observable will mirror the source exactly.
the window of silence that must pass in order for the observable to start echoing the last item
Creates a new Observable that emits the events of the source and then it also emits the given elements (appended to the stream).
Creates a new Observable that emits the events of the source and then it also emits the given elements (appended to the stream).
Emits the given exception instead of onComplete.
Emits the given exception instead of onComplete.
the exception to emit onComplete
a new Observable that emits an exception onComplete
Returns an Observable which emits a single value, either true, in case the given predicate holds for at least one item, or false otherwise.
Returns an Observable which emits a single value, either true, in case the given predicate holds for at least one item, or false otherwise.
is a function that evaluates the items emitted by the
source Observable, returning true if they pass the
filter
an Observable that emits only true or false in case the given predicate holds or not for at least one item
Returns an observable that emits a single Throwable, in case an error was thrown by the source, otherwise it isn't going to emit anything.
Returns an observable that emits a single Throwable, in case an error was thrown by the source, otherwise it isn't going to emit anything.
Only emits those items for which the given predicate holds.
Only emits those items for which the given predicate holds.
a function that evaluates the items emitted by the source
returning true if they pass the filter
a new observable that emits only those items in the source
for which the filter evaluates as true
Returns an Observable which only emits the first item for which the predicate holds.
Returns an Observable which only emits the first item for which the predicate holds.
is a function that evaluates the items emitted by the
source Observable, returning true if they pass the filter
an Observable that emits only the first item in the original
Observable for which the filter evaluates as true
Emits the first element emitted by the source, or otherwise if the
source is completed without emitting anything, then the
default is emitted.
Emits the first element emitted by the source, or otherwise if the
source is completed without emitting anything, then the
default is emitted.
Alias for headOrElse.
Applies a function that you supply to each item emitted by the source observable, where that function returns sequences that can be observed, and then concatenating those resulting sequences and emitting the results of this concatenation.
Applies a function that you supply to each item emitted by the source observable, where that function returns sequences that can be observed, and then concatenating those resulting sequences and emitting the results of this concatenation.
Alias for concatMap.
The difference between the concat operation
and mergeis that concat cares about the ordering of sequences
(e.g. all items emitted by the first observable in the sequence
will come before the elements emitted by the second observable),
whereas merge doesn't care about that (elements get
emitted as they come). Because of back-pressure applied to
observables, concat is safe to use in all contexts, whereas
merge requires buffering.
Applies a function that you supply to each item emitted by the source observable, where that function returns sequences and then concatenating those resulting sequences and emitting the results of this concatenation.
Applies a function that you supply to each item emitted by the source observable, where that function returns sequences and then concatenating those resulting sequences and emitting the results of this concatenation.
It's an alias for concatMapDelayError.
a function that, when applied to an item emitted by the source Observable, returns an Observable
an Observable that emits the result of applying the transformation function to each item emitted by the source Observable and concatenating the results of the Observables obtained from this transformation.
An alias of switchMap.
An alias of switchMap.
Returns a new observable that emits the items emitted by the observable most recently generated by the mapping function.
Applies a binary operator to a start value and to elements produced by the source observable, going from left to right, producing and concatenating observables along the way.
Applies a binary operator to a start value and to elements produced by the source observable, going from left to right, producing and concatenating observables along the way.
Applies a binary operator to a start value and to elements produced by the source observable, going from left to right, producing and concatenating observables along the way.
Applies a binary operator to a start value and to elements produced by the source observable, going from left to right, producing and concatenating observables along the way.
This version of flatScan delays all errors until onComplete,
when it will finally emit a CompositeException.
It's the combination between scan and flatMapDelayError.
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
You can combine the items emitted by multiple observables so that they act like a single sequence by using this operator.
The difference between the concat operation
and mergeis that concat cares about the ordering of sequences
(e.g. all items emitted by the first observable in the sequence
will come before the elements emitted by the second observable),
whereas merge doesn't care about that (elements get
emitted as they come). Because of back-pressure applied to
observables, concat is safe to use in all contexts, whereas
merge requires buffering.
Alias for concat.
an observable that emits items that are the result of flattening the items emitted by the observables emitted by the source
Alias for concatDelayError.
Alias for concatDelayError.
Concatenates the sequence of observables emitted by the source into one observable, without any transformation.
You can combine the items emitted by multiple observables so that they act like a single sequence by using this operator.
The difference between the concat operation
and mergeis that concat cares about the ordering of sequences
(e.g. all items emitted by the first observable in the sequence
will come before the elements emitted by the second observable),
whereas merge doesn't care about that (elements get
emitted as they come). Because of back-pressure applied to
observables, concat is safe to use in all contexts, whereas
merge requires buffering.
This version is reserving onError
notifications until all of the observables complete and only
then passing the issued errors(s) downstream. Note that
the streamed error is a
CompositeException,
since multiple errors from multiple streams can happen.
an observable that emits items that are the result of flattening the items emitted by the observables emitted by the source
Alias for switch
Alias for switch
Convert an observable that emits observables into a single observable that emits the items emitted by the most-recently-emitted of those observables.
Applies a binary operator to a start value and all elements of
this Observable, going left to right and returns a new
Observable that emits only one item before onComplete.
Applies a binary operator to a start value and all elements of
this Observable, going left to right and returns a new
Observable that emits only one item before onComplete.
Returns an Observable that emits a single boolean, either true, in case the given predicate holds for all the items emitted by the source, or false in case at least one item is not verifying the given predicate.
Returns an Observable that emits a single boolean, either true, in case the given predicate holds for all the items emitted by the source, or false in case at least one item is not verifying the given predicate.
is a function that evaluates the items emitted by the source
Observable, returning true if they pass the filter
an Observable that emits only true or false in case the given predicate holds or not for all the items
Subscribes to the source Observable and foreach element emitted
by the source it executes the given callback.
Subscribes to the source Observable and foreach element emitted
by the source it executes the given callback.
Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables, one GroupedObservable per group.
Groups the items emitted by an Observable according to a specified criterion, and emits these grouped items as GroupedObservables, one GroupedObservable per group.
Note: A GroupedObservable
will cache the items it is to emit until such time as it is
subscribed to. For this reason, in order to avoid memory leaks,
you should not simply ignore those GroupedObservables that do
not concern you. Instead, you can signal to them that they may
discard their buffers by doing something like source.take(0).
a function that extracts the key for each item
Only emits the first element emitted by the source observable, after which it's completed immediately.
Only emits the first element emitted by the source observable, after which it's completed immediately.
Emits the first element emitted by the source, or otherwise if the
source is completed without emitting anything, then the
default is emitted.
Emits the first element emitted by the source, or otherwise if the
source is completed without emitting anything, then the
default is emitted.
Alias for completed.
Alias for completed. Ignores all items emitted by the source and only calls onCompleted or onError.
an empty sequence that only calls onCompleted or onError, based on which one is called by the source Observable
Returns an Observable that emits true if the source Observable is empty, otherwise false.
Returns an Observable that emits true if the source Observable is empty, otherwise false.
Only emits the last element emitted by the source observable, after which it's completed immediately.
Only emits the last element emitted by the source observable, after which it's completed immediately.
Transforms the source using the given operator.
Transforms the source using the given operator.
Returns a new observable that applies the given function to each item emitted by the source and emits the result.
Returns a new observable that applies the given function to each item emitted by the source and emits the result.
Converts the source Observable that emits A into an Observable
that emits Notification[A].
Converts the source Observable that emits A into an Observable
that emits Notification[A].
Takes the elements of the source Observable and emits the element
that has the maximum key value, where the key is generated by
the given function f.
Takes the elements of the source Observable and emits the element
that has the maximum key value, where the key is generated by
the given function f.
Takes the elements of the source Observable and emits the maximum value, after the source has completed.
Takes the elements of the source Observable and emits the maximum value, after the source has completed.
Merges the sequence of Observables emitted by the source into one Observable, without any transformation.
Merges the sequence of Observables emitted by the source into one Observable, without any transformation.
You can combine the items emitted by multiple Observables so that they act like a single Observable by using this operator.
an Observable that emits items that are the
result of flattening the items emitted by the Observables
emitted by this.
this operation needs to do buffering and by not specifying an OverflowStrategy, the default strategy is being used.
Merges the sequence of Observables emitted by the source into one Observable, without any transformation.
Merges the sequence of Observables emitted by the source into one Observable, without any transformation.
You can combine the items emitted by multiple Observables so that they act like a single Observable by using this operator.
This version is reserving onError notifications until all of the observables complete and only then passing the issued errors(s) downstream. Note that the streamed error is a CompositeException, since multiple errors from multiple streams can happen.
an Observable that emits items that are the
result of flattening the items emitted by the Observables
emitted by this.
this operation needs to do buffering and by not specifying an OverflowStrategy, the default strategy is being used.
Creates a new observable by 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 observable and emitting the results of this merger.
Creates a new observable by 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 observable and emitting the results of this merger.
The difference between this and concatMap is that
concatMap cares about ordering of emitted
items (e.g. all items emitted by the first observable in
the sequence will come before the elements emitted by the
second observable), whereas merge doesn't care about
that (elements get emitted as they come). Because of
back-pressure applied to observables, the concat operation
is safe to use in all contexts, whereas merge requires
buffering.
- the transformation function
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.
Creates a new observable by 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 observable and emitting the results of this merger.
Creates a new observable by 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 observable and emitting the results of this merger.
The difference between this and concatMap is that
concatMap cares about ordering of emitted
items (e.g. all items emitted by the first observable in
the sequence will come before the elements emitted by the
second observable), whereas merge doesn't care about
that (elements get emitted as they come). Because of
back-pressure applied to observables, the concat operation
is safe to use in all contexts, whereas merge requires
buffering.
This version is reserving onError notifications until all of the observables complete and only then passing the issued errors(s) downstream. Note that the streamed error is a CompositeException, since multiple errors from multiple streams can happen.
- the transformation function
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.
Takes the elements of the source Observable and emits the element
that has the minimum key value, where the key is generated by
the given function f.
Takes the elements of the source Observable and emits the element
that has the minimum key value, where the key is generated by
the given function f.
Takes the elements of the source Observable and emits the minimum value, after the source has completed.
Takes the elements of the source Observable and emits the minimum value, after the source has completed.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers).
Returns an Observable that emits false if the source Observable is empty, otherwise true.
Returns an Observable that emits false if the source Observable is empty, otherwise true.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
the streaming of events continues with the specified backup
sequence.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
the streaming of events continues with the specified backup
sequence.
The created Observable mirrors the behavior of the source in case the source does not end with an error.
NOTE that compared with onErrorResumeNext from Rx.NET, the
streaming is not resumed in case the source is terminated
normally with an onComplete.
is a backup sequence that's being subscribed in case the source terminates with an error.
Returns an observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which
case the streaming of events fallbacks to an observable
emitting a single element generated by the backup function.
Returns an observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which
case the streaming of events fallbacks to an observable
emitting a single element generated by the backup function.
The created Observable mirrors the behavior of the source
in case the source does not end with an error or if the
thrown Throwable is not matched.
- a partial function that matches errors with a backup element that is emitted when the source throws an error.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
the streaming of events continues with the specified backup
sequence generated by the given partial function.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
the streaming of events continues with the specified backup
sequence generated by the given partial function.
The created Observable mirrors the behavior of the source in
case the source does not end with an error or if the thrown
Throwable is not matched.
is a partial function that matches errors with a backup throwable that is subscribed when the source throws an error.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
it tries subscribing to the source again in the hope that it
will complete without an error.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
it tries subscribing to the source again in the hope that it
will complete without an error.
The number of retries is limited by the specified maxRetries
parameter, so for an Observable that always ends in error the
total number of subscriptions that will eventually happen is
maxRetries + 1.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
it tries subscribing to the source again in the hope that it
will complete without an error.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
it tries subscribing to the source again in the hope that it
will complete without an error.
The given predicate establishes if the subscription should be retried or not.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
it tries subscribing to the source again in the hope that it
will complete without an error.
Returns an Observable that mirrors the behavior of the source,
unless the source is terminated with an onError, in which case
it tries subscribing to the source again in the hope that it
will complete without an error.
NOTE: The number of retries is unlimited, so something like
Observable.error(new RuntimeException).onErrorRetryUnlimited
will loop forever.
Given a Pipe, transform the source observable with it.
Given a Pipe, transform the source observable with it.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers). The underlying subject used is a PublishSubject.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers). The underlying subject used is a AsyncSubject.
Applies a binary operator to a start value and all elements of
this Observable, going left to right and returns a new
Observable that emits only one item before onComplete.
Applies a binary operator to a start value and all elements of
this Observable, going left to right and returns a new
Observable that emits only one item before onComplete.
Repeats the items emitted by the source continuously.
Repeats the items emitted by the source continuously. It
caches the generated items until onComplete and repeats them
forever. On error it terminates.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers). The underlying subject used is a ReplaySubject.
is the size of the buffer limiting the number of items that can be replayed (on overflow the head starts being dropped)
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers). The underlying subject used is a ReplaySubject.
Emit the most recent items emitted by the source within periodic time intervals.
Emit the most recent items emitted by the source within periodic time intervals.
Use the sample operator to periodically look at an observable
to see what item it has most recently emitted since the previous
sampling. Note that if the source observable has emitted no
items since the last time it was sampled, the observable that
results from the sample operator will emit no item for that
sampling period.
the timespan at which sampling occurs
sampleRepeated for repeating the last value on silence
sampleBy for fine control
Returns an observable that, when the specified sampler emits an item or completes, emits the most recently emitted item (if any) emitted by the source since the previous emission from the sampler.
Returns an observable that, when the specified sampler emits an item or completes, emits the most recently emitted item (if any) emitted by the source since the previous emission from the sampler.
Use the sampleBy operator to periodically look at an observable
to see what item it has most recently emitted since the previous
sampling. Note that if the source observable has emitted no
items since the last time it was sampled, the observable that
results from the sampleBy operator will emit no item.
- the observable to use for sampling the source
sampleRepeatedBy for repeating the last value on silence
sample for periodic sampling
Emit the most recent items emitted by an observable within periodic time intervals.
Emit the most recent items emitted by an observable within periodic time intervals. If no new value has been emitted since the last time it was sampled, it signals the last emitted value anyway.
the timespan at which sampling occurs
sampleRepeatedBy for fine control
sample for a variant that doesn't repeat the last value on silence
Returns an observable that, when the specified sampler observable emits an item or completes, emits the most recently emitted item (if any) emitted by the source Observable since the previous emission from the sampler observable.
Returns an observable that, when the specified sampler observable emits an item or completes, emits the most recently emitted item (if any) emitted by the source Observable since the previous emission from the sampler observable. If no new value has been emitted since the last time it was sampled, it signals the last emitted value anyway.
- the Observable to use for sampling the source Observable
sampleRepeated for a periodic sampling
sampleBy for a variant that doesn't repeat the last value on silence
Applies a binary operator to a start value and all elements of this Observable, going left to right and returns a new Observable that emits on each step the result of the applied function.
Applies a binary operator to a start value and all elements of this Observable, going left to right and returns a new Observable that emits on each step the result of the applied function.
Similar to foldLeftF, but emits the state on each step. Useful for modeling finite state machines.
Returns a new Observable that multi-casts (shares) the original Observable.
Returns a new Observable that multi-casts (shares) the original Observable.
Creates a new Observable that emits the given elements and then it also emits the events of the source (prepend operation).
Creates a new Observable that emits the given elements and then it also emits the events of the source (prepend operation).
Subscribes to the stream.
Subscribes to the stream.
a subscription that can be used to cancel the streaming.
Subscribes to the stream.
Subscribes to the stream.
a subscription that can be used to cancel the streaming.
Subscribes to the stream.
Subscribes to the stream.
a subscription that can be used to cancel the streaming.
Subscribes to the stream.
Subscribes to the stream.
a subscription that can be used to cancel the streaming.
Subscribes to the stream.
Subscribes to the stream.
a subscription that can be used to cancel the streaming.
Subscribes to the stream.
Subscribes to the stream.
a subscription that can be used to cancel the streaming.
Returns a new Observable that uses the specified Scheduler for
initiating the subscription.
Returns a new Observable that uses the specified Scheduler for
initiating the subscription.
Given a source that emits numeric values, the sum operator sums
up all values and at onComplete it emits the total.
Given a source that emits numeric values, the sum operator sums
up all values and at onComplete it emits the total.
Convert an observable that emits observables into a single observable that emits the items emitted by the most-recently-emitted of those observables.
Convert an observable that emits observables into a single observable that emits the items emitted by the most-recently-emitted of those observables.
Returns a new observable that emits the items emitted by the observable most recently generated by the mapping function.
Returns a new observable that emits the items emitted by the observable most recently generated by the mapping function.
Drops the first element of the source observable, emitting the rest.
Drops the first element of the source observable, emitting the rest.
Selects the first n elements (from the start).
Selects the first n elements (from the start).
the number of elements to take
a new Observable that emits only the first
n elements from the source
Creates a new Observable that emits the events of the source, only
for the specified timestamp, after which it completes.
Creates a new Observable that emits the events of the source, only
for the specified timestamp, after which it completes.
the window of time during which the new Observable is allowed to emit the events of the source
Creates a new observable that only emits the last n elements
emitted by the source.
Creates a new observable that only emits the last n elements
emitted by the source.
In case the source triggers an error, then the underlying buffer gets dropped and the error gets emitted immediately.
Takes longest prefix of elements that satisfy the given predicate and returns a new Observable that emits those elements.
Takes longest prefix of elements that satisfy the given predicate and returns a new Observable that emits those elements.
Takes longest prefix of elements that satisfy the given predicate and returns a new Observable that emits those elements.
Takes longest prefix of elements that satisfy the given predicate and returns a new Observable that emits those elements.
Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration.
Returns an Observable that emits only the first item emitted by the source Observable during sequential time windows of a specified duration.
This differs from Observable!.throttleLast in that this only
tracks passage of time whereas throttleLast ticks at scheduled
intervals.
time to wait before emitting another item after emitting the last item
Emit the most recent items emitted by the source within periodic time intervals.
Emit the most recent items emitted by the source within periodic time intervals.
Alias for sample.
duration of windows within which the last item emitted by the source Observable will be emitted
Only emit an item from an observable if a particular timespan has passed without it emitting another item.
Only emit an item from an observable if a particular timespan has passed without it emitting another item.
Note: If the source observable keeps emitting items more frequently than the length of the time window, then no items will be emitted by the resulting observable.
Alias for debounce.
the length of the window of time that must pass after the emission of an item from the source observable in which that observable emits no items in order for the item to be emitted by the resulting observable
echoOnce for a similar operator that also mirrors the source observable
Returns an observable that mirrors the source but that will trigger a
DownstreamTimeoutException
in case the downstream subscriber takes more than the given timespan
to process an onNext message.
Returns an observable that mirrors the source but that will trigger a
DownstreamTimeoutException
in case the downstream subscriber takes more than the given timespan
to process an onNext message.
Note that this ignores the time it takes for the upstream to send
onNext messages. For detecting slow producers see timeoutOnSlowUpstream.
maximum duration for onNext.
Returns an observable that mirrors the source but applies a timeout for each emitted item by the upstream.
Returns an observable that mirrors the source but applies a timeout for each emitted item by the upstream. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the resulting Observable terminates and notifies observers of a TimeoutException.
Note that this ignores the time it takes to process onNext.
If dealing with a slow consumer, see timeoutOnSlowDownstream.
maximum duration between emitted items before
a timeout occurs (ignoring the time it takes to process onNext)
Returns an observable that mirrors the source but applies a timeout for each emitted item by the upstream.
Returns an observable that mirrors the source but applies a timeout for each emitted item by the upstream. If the next item isn't emitted within the specified timeout duration starting from its predecessor, the source is terminated and the downstream gets subscribed to the given backup.
Note that this ignores the time it takes to process onNext.
If dealing with a slow consumer, see timeoutOnSlowDownstream.
maximum duration between emitted items before
a timeout occurs (ignoring the time it takes to process onNext)
is the alternative data source to subscribe to on timeout
Wraps this Observable into a org.reactivestreams.Publisher.
Wraps this Observable into a org.reactivestreams.Publisher.
See the Reactive Streams
protocol that Monix implements.
Transforms the source using the given transformer function.
Transforms the source using the given transformer function.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e. whose source is shared by all observers).
This operator is unsafe because Subject objects are stateful
and have to obey the Observer contract, meaning that they
shouldn't be subscribed multiple times, so they are error
prone. Only use if you know what you're doing, otherwise prefer
the safe multicast operator.
Characteristic function for an Observable instance, that creates
the subscription and that eventually starts the streaming of
events to the given Observer, being meant to be provided.
Characteristic function for an Observable instance, that creates
the subscription and that eventually starts the streaming of
events to the given Observer, being meant to be provided.
This function is "unsafe" to call because it does not protect
the calls to the given Observer implementation in regards to
unexpected exceptions that violate the contract, therefore the
given instance must respect its contract and not throw any
exceptions when the observable calls onNext, onComplete and
onError. If it does, then the behavior is undefined.
While the destination observer is busy, buffers events, applying the given overflowStrategy.
While the destination observer is busy, buffers events, applying the given overflowStrategy.
- the overflow strategy used for buffering, which specifies what to do in case we're dealing with a slow consumer - should an unbounded buffer be used, should back-pressure be applied, should the pipeline drop newer or older events, should it drop the whole buffer? See OverflowStrategy for more details.
While the destination observer is busy, drop the incoming events.
While the destination observer is busy, drop the incoming events.
While the destination observer is busy, drop the incoming events.
While the destination observer is busy, drop the incoming events. When the downstream recovers, we can signal a special event meant to inform the downstream observer how many events where dropped.
- a function that is used for signaling a special event used to inform the consumers that an overflow event happened, function that receives the number of dropped events as a parameter (see OverflowStrategy.Evicted)
Creates a new observable from this observable and another given observable by combining their items in pairs in a strict sequence.
Creates a new observable from this observable and another given observable by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the tuple of the first items emitted by each of the source observables; the second item emitted by the new observable will be a tuple with the second items emitted by each of those observables; and so forth.
See combineLatest for a more relaxed alternative that doesn't combine items in strict sequence.
is an observable that gets paired with the source
a new observable sequence that emits the paired items of the source observables
Creates a new observable from this observable and another given observable by combining their items in pairs in a strict sequence.
Creates a new observable from this observable and another given observable by combining their items in pairs in a strict sequence.
So the first item emitted by the new observable will be the result of the function applied to the first item emitted by each of the source observables; the second item emitted by the new observable will be the result of the function applied to the second item emitted by each of those observables; and so forth.
See combineLatestWith for a more relaxed alternative that doesn't combine items in strict sequence.
is an observable that gets paired with the source
is a mapping function over the generated pairs
Zips the emitted elements of the source with their indices.
Zips the emitted elements of the source with their indices.
BehaviorSubjectwhen subscribed, will emit the most recently emitted item by the source, or theinitialValue(as the seed) in case no value has yet been emitted, then continuing to emit events subsequent to the time of invocation.When the source terminates in error, the
BehaviorSubjectwill not emit any items to subsequent subscribers, but instead it will pass along the error notification.Subject