AsyncSubject
Related Docs:
object AsyncSubject
| package subjects
Concatenates the source Observable with the other Observable, as specified.
Concatenates the source Observable with the other Observable, as specified.
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 Future and then cancels the subscription.
Returns the first generated result as a Future and then cancels the subscription.
Forces a buffered asynchronous boundary.
Forces a buffered asynchronous boundary.
Internally it wraps the observer implementation given to subscribeFn into a
BufferedSubscriber.
Normally Monifu'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 policy, see BufferPolicy for options.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e.
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.
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 the reached the
given count.
So in this example, we are creating a new observable that emits sequences of
exactly 10 elements (or whatever is in the buffer when onComplete happens):
observable.buffer(10)the 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, or when the buffer
size has reached the given count.
is the maximum bundle size
the interval of time at which it should emit the buffered bundle
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.
the interval of time at which it should emit the buffered bundle
Returns an Observable by applying the given partial function to the source observable for each element for which the given partial function is defined.
Returns an Observable by applying the given partial function to the source observable for each element for which the given partial function is defined.
Useful to be used instead of a filter & map combination.
the function that filters and maps the resulting observable
an Observable that emits the transformed items by the given partial function
Creates a new Observable from this Observable and another given Observable.
Creates a new Observable from this Observable and another given Observable.
This operator behaves in a similar way to zip, but while zip emits items
only when all of the zipped source Observables have emitted a previously unzipped item,
combine emits an item whenever any of the source Observables emits
an item (so long as each of the source Observables has emitted at least one item).
Creates a new Observable from this Observable and another given Observable.
Creates a new Observable from this Observable and another given Observable.
It's like Observable.combineLatest, except that the created observable is reserving onError notifications until all of the combined Observables complete and only then passing it along to the observers.
Returns an Observable that doesn't emit anything, but that completes when the source Observable completes.
Returns an Observable that doesn't emit anything, but that completes when the source Observable completes.
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 Observable by using this method.
The difference between concat and merge is
that concat 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,
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 this
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.
It's like Observable.concat, except that the created observable is reserving onError notifications until all of the merged Observables complete and only then passing it along to the observers.
an Observable that emits items that are the result of flattening the items emitted
by the Observables emitted by this
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 concatenating those resulting Observables and emitting the results of this concatenation.
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 concatenating those resulting Observables and emitting the results of this concatenation.
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.
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 concatenating those resulting Observables and emitting the results of this concatenation.
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 concatenating those resulting Observables and emitting the results of this concatenation.
It's like Observable.concatMap, except that the created observable is reserving onError notifications until all of the merged Observables complete and only then passing it along to the observers.
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.
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
Emit items from the source Observable, or emit a default item if the source Observable completes after emitting no items.
Emit items from the source Observable, or emit a default item if the source Observable completes after emitting no items.
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 future completes,
before passing it on to the source Observable.
Hold an Observer's subscription request until the given future completes,
before passing it on to the source Observable. If the given future
completes in error, then the subscription is terminated with onError.
the Future that must complete in order for the
subscription to happen.
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 the duplicate elements emitted by the source Observable.
Suppress the duplicate elements emitted by the source Observable.
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.
Executes the given callback if the downstream observer has canceled the streaming.
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 only for the first element generated by the source Observable, useful for doing a piece of computation only when the stream started.
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 started.
a new Observable that executes the specified callback only for the first element
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
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 is must drop the events emitted by the source
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.
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 that emits a single Throwable, in case an error was thrown by the source Observable, 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 Observable, otherwise it isn't going to emit anything.
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.
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 which only emits those items for which the given predicate holds.
Returns an Observable which only emits those items for which the given predicate holds.
a function that evaluates the items emitted by the source Observable,
returning true if they pass the filter
an Observable that emits only those items in the original Observable
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.
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.
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 concatenating those resulting Observables and emitting the results of this concatenation.
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 concatenating those resulting Observables and emitting the results of this concatenation.
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.
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 concatenating those resulting Observables and emitting the results of this concatenation.
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 concatenating those resulting Observables and emitting the results of this concatenation.
It's an alias for Observable.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.
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.
It's the combination between scan and monifu.reactive.Observable.flatten.
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.
It's the combination between scan and monifu.reactive.Observable.flattenDelayError.
Flattens the sequence of Observables emitted by the source into one Observable, without any transformation.
Flattens the sequence of Observables emitted by the source into one Observable, without any transformation.
It's an alias for Observable.concat.
an Observable that emits items that are the result of flattening the items emitted
by the Observables emitted by this
Flattens the sequence of Observables emitted by the source into one Observable, without any transformation.
Flattens the sequence of Observables emitted by the source into one Observable, without any transformation. Delays errors until the end.
It's an alias for Observable.concatDelayError.
an Observable that emits items that are the result of flattening the items emitted
by the Observables emitted by this
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.
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.
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.
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.
Given a function that transforms an Observable[T] into an Observable[U],
it transforms the source observable into an Observable[U].
Given a function that transforms an Observable[T] into an Observable[U],
it transforms the source observable into an Observable[U].
Returns an Observable that applies the given function to each item emitted by an Observable and emits the result.
Returns an Observable that applies the given function to each item emitted by an Observable and emits the result.
a function to apply to each item emitted by the Observable
an Observable that emits the items from the source Observable, transformed by the given function
Converts the source Observable that emits T into an Observable
that emits Notification[T].
Converts the source Observable that emits T into an Observable
that emits Notification[T].
NOTE: onComplete is still emitted after an onNext(OnComplete) notification
however an onError(ex) notification is emitted as an onNext(OnError(ex))
followed by an onComplete.
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.
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.
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 method.
The difference between concat and merge is that concat 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,
concat is safe to use in all contexts, whereas merge requires buffering.
the policy used for buffering, useful if you want to limit the buffer size and apply back-pressure, trigger and error, etc... see the available buffer policies.
an Observable that emits items that are the result of flattening the items emitted
by the Observables emitted by this
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 method.
It's like Observable.merge, except that the created observable is reserving onError notifications until all of the merged Observables complete and only then passing it along to the observers.
the policy used for buffering, useful if you want to limit the buffer size and apply back-pressure, trigger and error, etc... see the available buffer policies.
an Observable that emits items that are the result of flattening the items emitted
by the Observables emitted by this
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 Observables 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 Observables and emitting the results of this merger.
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 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 Observables 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 Observables and emitting the results of this merger.
It's like Observable.mergeMap, except that the created observable is reserving onError notifications until all of the merged Observables complete and only then passing it along to the observers.
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 merging the results of the Observables obtained from this transformation.
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.
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.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e.
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.
- 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 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.
NOTE that compared with onErrorResumeNext from Rx.NET,
the streaming is not resumed in case the source is
terminated normally with an onComplete.
- 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.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e.
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.e.
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.
Wraps this Observable into a org.reactivestreams.Publisher.
Wraps this Observable into a org.reactivestreams.Publisher.
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 this Observable continuously.
Repeats the items emitted by this Observable continuously. It caches the generated items until onComplete
and repeats them ad infinitum. On error it terminates.
Converts this observable into a multicast observable, useful for turning a cold observable into a hot one (i.e.
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 an Observable within periodic time intervals.
Emit the most recent items emitted by an Observable within periodic time intervals.
Use the sample() method 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 initial delay after which sampling can happen
the timespan at which sampling occurs and note that this is
not accurate as it is subject to back-pressure concerns - as in
if the delay is 1 second and the processing of an event on onNext
in the observer takes one second, then the actual sampling delay
will be 2 seconds.
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.
Use the sample() method 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 and note that this is
not accurate as it is subject to back-pressure concerns - as in
if the delay is 1 second and the processing of an event on onNext
in the observer takes one second, then the actual sampling delay
will be 2 seconds.
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, the emit the last emitted value anyway.
Also see Observable!.sample.
the initial delay after which sampling can happen
the timespan at which sampling occurs and note that this is
not accurate as it is subject to back-pressure concerns - as in
if the delay is 1 second and the processing of an event on onNext
in the observer takes one second, then the actual sampling delay
will be 2 seconds.
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, the emit the last emitted value anyway.
Also see Observable.sample.
the timespan at which sampling occurs and note that this is
not accurate as it is subject to back-pressure concerns - as in
if the delay is 1 second and the processing of an event on onNext
in the observer takes one second, then the actual sampling delay
will be 2 seconds.
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 foldLeft, but emits the state on each step. Useful for modeling finite state machines.
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).
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and starts the stream.
Creates the subscription and that starts the stream.
Creates the subscription and that starts the stream.
is an Observer on which onNext, onComplete and onError
happens, according to the Monifu Rx contract.
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 overridden in custom combinators
or in classes implementing Observable.
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 overridden in custom combinators
or in classes implementing Observable.
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.
Drops the first element of the source observable, emitting the rest.
Drops the first element of the source observable, emitting the rest.
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
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 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.
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.
Creates the subscription that eventually starts the stream.
Creates the subscription that eventually starts the stream.
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.
Creates the subscription that eventually starts the stream.
Creates the subscription that eventually starts the stream.
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.
is an Observer that respects Monifu Rx contract.
While the destination observer is busy, buffers events then send whatever was buffered in one big batch.
While the destination observer is busy, buffers events then send whatever was buffered in one big batch.
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.
is a function used to build a message that will be the first event sent after the observer recovers, a function receiving as argument the number of dropped messages and thus can be used to inform the downstream how many messages it missed.
Creates a new Observable from this Observable and another given Observable, by emitting elements combined in pairs.
Creates a new Observable from this Observable and another given Observable, by emitting elements combined in pairs. If one of the Observable emits fewer events than the other, then the rest of the unpaired events are ignored.
An
AsyncSubjectemits the last value (and only the last value) emitted by the source Observable, and only after that source Observable completes.If the source terminates with an error, the
AsyncSubjectwill not emit any items to subsequent subscribers, but will simply pass along the error notification from the source Observable.