hu.akarnokd.reactive4java.query

Class ObservableBuilder<T>

java.lang.Object

hu.akarnokd.reactive4java.query.ObservableBuilder<T>

Type Parameters:

T - the element type

All Implemented Interfaces:

Observable<T>

public final class ObservableBuilder<T>
extends java.lang.Object
implements Observable<T>

Wrapper object around an Observable which lets the user chain some Reactive operators.

This builder is the dual of the IterableBuilder class.

Field Summary

Fields

Modifier and Type	Field and Description
protected Observable<T>	o The backed observable.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ObservableBuilder(Observable<T> source) Constructor.

Method Summary

Modifier and Type	Method and Description
ObservableBuilder<TimeInterval<T>>	addTimeInterval() Returns an observable which provides a TimeInterval of Ts which records the elapsed time between successive elements.
ObservableBuilder<Timestamped<T>>	addTimestamped() Wrap the values within a observable to a timestamped value having always the System.currentTimeMillis() value.
ObservableBuilder<T>	aggregate(Func2<? super T,? super T,? extends T> accumulator) Apply an accumulator function over the observable source and submit the accumulated value to the returned observable.
<U,V> ObservableBuilder<V>	aggregate(Func2<? super U,? super T,? extends U> sum, Func2<? super U,? super java.lang.Integer,? extends V> divide) Computes an aggregated value of the source Ts by applying a sum function and applying the divide function when the source finishes, sending the result to the output.
<U> ObservableBuilder<U>	aggregate(U seed, Func2<? super U,? super T,? extends U> accumulator) Apply an accumulator function over the observable source and submit the accumulated value to the returned observable.
<U,V> ObservableBuilder<V>	aggregate(U seed, Func2<? super U,? super T,? extends U> accumulator, Func1<? super U,? extends V> resultSelector) Aggregates the sequence via the accumulator function and transforms the result value with the selector.
<U,V> ObservableBuilder<V>	aggregate(U seed, Func2<? super U,? super T,? extends U> accumulator, Func2<? super U,? super java.lang.Integer,? extends V> divider) Computes an aggregated value of the source Ts by using the initial seed, applying an accumulator function and applying the divide function when the source finishes, sending the result to the output.
ObservableBuilder<java.lang.Boolean>	all(Func1<? super T,java.lang.Boolean> predicate) Signals a single true or false if all elements of the observable matches the predicate.
ObservableBuilder<T>	amb(java.lang.Iterable<? extends Observable<? extends T>> others) Channels the values of the first observable who fires first from the given set of observables.
ObservableBuilder<T>	amb(Observable<? extends T> other) Channels the values from the first observable (this or other) who fires firts.
ObservableBuilder<java.lang.Boolean>	any() Signals a single true if the source observable contains any element.
ObservableBuilder<java.lang.Boolean>	any(Func1<? super T,java.lang.Boolean> predicate) Signals a single TRUE if the source signals any next() and the value matches the predicate before it signals a finish().
ObservableBuilder<java.math.BigDecimal>	averageBigDecimal() Computes and signals the average value of the BigDecimal source.
ObservableBuilder<java.math.BigDecimal>	averageBigInteger() Computes and signals the average value of the BigInteger source.
ObservableBuilder<java.lang.Double>	averageDouble() Computes and signals the average value of the Double source.
ObservableBuilder<java.lang.Float>	averageFloat() Computes and signals the average value of the Float source.
ObservableBuilder<java.lang.Double>	averageInt() Computes and signals the average value of the integer source.
ObservableBuilder<java.lang.Double>	averageLong() Computes and signals the average value of the Long source.
T	await() Waits indefinitely for the observable to complete and returns the last value.
T	await(long time, java.util.concurrent.TimeUnit unit) Waits a limited amount of time for the observable to complete and returns the last value.
<U> ObservableBuilder<java.util.List<T>>	buffer(Func0<Observable<U>> windowClosingSelector) Buffer parts of the source until the window observable finishes.
ObservableBuilder<java.util.List<T>>	buffer(int bufferSize) Buffer the nodes as they become available and send them out in bufferSize chunks.
ObservableBuilder<java.util.List<T>>	buffer(int bufferSize, int skip) Buffer the nodes as they become available and send them out in bufferSize chunks.
ObservableBuilder<java.util.List<T>>	buffer(int bufferSize, long time, java.util.concurrent.TimeUnit unit) Buffer the Ts of the source until the buffer reaches its capacity or the current time unit runs out.
ObservableBuilder<java.util.List<T>>	buffer(int bufferSize, long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Buffer the Ts of the source until the buffer reaches its capacity or the current time unit runs out.
ObservableBuilder<java.util.List<T>>	buffer(long time, java.util.concurrent.TimeUnit unit) Buffers the source observable Ts into a list of Ts periodically and submits them to the returned observable.
ObservableBuilder<java.util.List<T>>	buffer(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Buffers the source observable Ts into a list of Ts periodically and submits them to the returned observable.
<U,V> ObservableBuilder<java.util.List<T>>	buffer(Observable<? extends U> windowOpening, Func1<? super U,? extends Observable<V>> windowClosing) Projects the incoming values into multiple buffers based on when a window-open fires an event and a window-close finishes.
<U> ObservableBuilder<java.util.List<T>>	buffer(Observable<U> boundary) Buffers the source elements into non-overlapping lists separated by notification values from the boundary observable and its finish event.
<U> ObservableBuilder<U>	cast() Casts the values of this observable implicitly and forwards a ClassCastException if it occurs.
<U> ObservableBuilder<U>	cast(java.lang.Class<U> token) Casts the values of this observable via the given type token or forwards a ClassCastException.
java.lang.Iterable<java.util.List<T>>	chunkify() Produces an iterable sequence of consequtive (possibly empty) chunks of the source sequence.
<U> java.lang.Iterable<U>	collect(Func0<? extends U> newCollector, Func2<? super U,? super T,? extends U> merge) Produces an enumerable sequence that returns elements collected/aggregated/whatever from the source between consequtive iterations.
<U> CloseableIterable<U>	collect(Func0<? extends U> initialCollector, Func2<? super U,? super T,? extends U> merge, Func1<? super U,? extends U> newCollector) Produces an iterable sequence that returns elements collected/aggregated/whatever from the source sequence between consequtive iteration.
ObservableBuilder<java.util.List<T>>	combineFirst(java.util.List<? extends Observable<? extends T>> srcs) Combine the incoming Ts of the various observables into a single list of Ts like using Reactive.zip() on more than two sources.
<U,V> ObservableBuilder<V>	combineLatest(Observable<? extends U> right, Func2<? super T,? super U,? extends V> selector) Returns an observable which combines the latest values of both streams whenever one sends a new value, but only after both sent a value.
<U,V> ObservableBuilder<V>	combineLatest0(Observable<? extends U> right, Func2<? super T,? super U,? extends V> selector) Returns an observable which combines the latest values of both streams whenever one sends a new value.
ObservableBuilder<T>	concat(java.lang.Iterable<? extends Observable<? extends T>> sources) Concatenates the source observables in a way that when the first finish(), the second gets registered and continued, and so on.
ObservableBuilder<T>	concat(Observable<? extends T> second) Concatenate two observables in a way when the first finish() the second is registered and continued with.
ObservableBuilder<T>	concatAll(Observable<? extends Observable<? extends T>> sources) Concatenate the the multiple sources of T one after another.
java.io.Closeable	connect() Connect this observable if the underlying observable supports the ConnectableObservable interface, or throw an UnsupportedOperationException.
ObservableBuilder<java.lang.Boolean>	contains(Func0<? extends T> supplier) Signals a single TRUE if the source observable signals a value equals() with the supplied value.
ObservableBuilder<java.lang.Boolean>	contains(T value) Signals a single TRUE if the source observable signals a value equals() with the source value.
ObservableBuilder<java.lang.Integer>	count() Counts the number of elements in the observable source.
ObservableBuilder<java.lang.Integer>	count(Func1<? super T,java.lang.Boolean> predicate) Counts the number of elements where the predicate returns true.
ObservableBuilder<java.lang.Long>	countLong() Counts the number of elements in the observable source as a long.
ObservableBuilder<java.lang.Integer>	countLong(Func1<? super T,java.lang.Boolean> predicate) Counts the number of elements where the predicate returns true as long.
ObservableBuilder<T>	debugState() Constructs an observer which logs errors in case next(), finish() or error() is called and the observer is not in running state anymore due an earlier finish() or error() call.
ObservableBuilder<T>	defaultIfEmpty(Func0<? extends T> defaultValueFunc) Returns the default value provided by the function if the source sequence is empty.
ObservableBuilder<T>	defaultIfEmpty(T defaultValue) Returns the default value if the source sequence is empty.
static <T> ObservableBuilder<T>	defer(Func0<? extends Observable<? extends T>> observableFactory) The returned observable invokes the observableFactory whenever an observer tries to subscribe to it.
<U> ObservableBuilder<T>	delay(Func1<? super T,? extends Observable<U>> delaySelector) Delays (ties) the event delivery of the source, for each source value T, to the firing of the observable returned by the delay selector.
ObservableBuilder<T>	delay(long time, java.util.concurrent.TimeUnit unit) Delays the propagation of events of the source by the given amount.
ObservableBuilder<T>	delay(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Delays the propagation of events of the source by the given amount.
<U,V> ObservableBuilder<T>	delay(Observable<U> registerDelay, Func1<? super T,? extends Observable<V>> delaySelector) Delays (ties) the event delivery of the source to the firing of registerDelay (optionally) and for each source value T, to the firing of the observable returned by the delay selector.
ObservableBuilder<T>	delayRegister(long time, java.util.concurrent.TimeUnit unit) Delays the registration to the underlying observable by a given amount.
ObservableBuilder<T>	delayRegister(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Delays the registration to the underlying observable by a given amount.
ObservableBuilder<T>	dematerialize() Returns an observable which converts all option messages back to regular next(), error() and finish() messages.
ObservableBuilder<T>	distinct() Returns the distinct elements from the source.
<U> ObservableBuilder<T>	distinct(Func1<? super T,? extends U> keyExtractor, Func2<? super U,? super U,java.lang.Boolean> keyComparer) Returns a sequence of elements who are distinct in terms of the given key extracted by a function and compared against each other via the comparer function.
<U> ObservableBuilder<T>	distinct(Func1<T,U> keyExtractor) Returns a sequence of elements distinct in terms of the key extracted from them.
ObservableBuilder<T>	distinct(Func2<? super T,? super T,java.lang.Boolean> comparer) Returns the distinct elements from the source according to the given comparator function.
ObservableBuilder<T>	doWhile(Func0<java.lang.Boolean> condition) Repeats the given source so long as the condition returns true.
ObservableBuilder<java.lang.Void>	drain(Func1<? super T,? extends Observable<java.lang.Void>> pump) Maintains a queue of Ts which is then drained by the pump.
ObservableBuilder<java.lang.Void>	drain(Func1<? super T,? extends Observable<java.lang.Void>> pump, Scheduler pool) Maintains a queue of Ts which is then drained by the pump.
ObservableBuilder<T>	elementAt(int index) Returns a single element from the sequence at the index or throws a NoSuchElementException if the sequence terminates before this index.
ObservableBuilder<T>	elementAt(int index, Func0<? extends T> defaultSupplier) Returns a single element from the sequence at the index or the default value supplied if the sequence terminates before this index.
ObservableBuilder<T>	elementAt(int index, T defaultValue) Returns a single element from the sequence at the index or the default value if the sequence terminates before this index.
ObservableBuilder<T>	empty() Returns an empty observable, which fires only finish().
ObservableBuilder<T>	empty(Scheduler pool) Returns an empty observable which signals only finish() on the given pool.
ObservableBuilder<T>	finish(Action0 action) Invokes the given action when the source signals a finish() or error().
T	first() Blocks until the first element of the observable becomes available and returns that element.
T	first(Func0<? extends T> defaultSupplier) Blocks until the first element of the observable becomes available and returns that element or returns the supplier's value if the observable is empty.
T	first(T defaultValue) Blocks until the first element of the observable becomes available and returns that element or returns the default value if the observable is empty.
ObservableBuilder<T>	firstAsync() Returns an observable which takes the first value from the source observable as a single element or throws NoSuchElementException if the source is empty.
ObservableBuilder<T>	firstAsync(Func0<? extends T> defaultSupplier) Returns an observable which takes the first value from the source observable as a single element or the supplier's value if the source is empty.
ObservableBuilder<T>	firstAsync(T defaultValue) Returns an observable which takes the first value from the source observable as a single element or the default value if the source is empty.
void	forEach(Action1<? super T> action) Invokes the action on each element in the source, and blocks until the source terminates either way.
boolean	forEach(Action1<? super T> action, long time, java.util.concurrent.TimeUnit unit) Invokes the action on each element in the source, and blocks until the source terminates or the time runs out.
void	forEach(Action2<? super T,? super java.lang.Integer> action) Invokes the indexed action on each element in the source, and blocks until the source terminates either way.
boolean	forEach(Action2<? super T,? super java.lang.Integer> action, long time, java.util.concurrent.TimeUnit unit) Invokes the indexed action on each element in the source, and blocks until the source terminates either way.
ObservableBuilder<java.util.List<T>>	forkJoin(java.lang.Iterable<? extends Observable<? extends T>> sources) Runs the observables in parallel and joins their last values whenever one fires.
static ObservableBuilder<java.lang.Void>	from(Action0 action) Invokes the action asynchronously on the given pool and relays its finish() or error() messages.
static ObservableBuilder<java.lang.Void>	from(Action0 action, Scheduler pool) Invokes the action asynchronously on the given pool and relays its finish() or error() messages.
static <T> ObservableBuilder<T>	from(java.util.concurrent.Callable<? extends T> call) Invoke the given callable on the default pool and observe its result via the returned observable.
static <T> ObservableBuilder<T>	from(java.util.concurrent.Callable<? extends T> call, Scheduler pool) Invoke the given callable on the given pool and observe its result via the returned observable.
static <T> ObservableBuilder<T>	from(Func0<? extends T> func) Invokes the function asynchronously on the default pool and relays its result followed by a finish.
static <T> ObservableBuilder<T>	from(Func0<? extends T> func, Scheduler pool) Invokes the function asynchronously on the given pool and relays its result followed by a finish.
static <T> ObservableBuilder<T>	from(java.lang.Iterable<? extends T> source) Creates an observable builder from the source sequence by using the default scheduler to emit the values.
static <T> ObservableBuilder<T>	from(java.lang.Iterable<? extends T> source, Scheduler scheduler) Creates an observable builder from the source sequence and uses the given schduler to emit the values.
static <T> ObservableBuilder<T>	from(Observable<T> source) Wraps the supplied observable sequence into an observable builder or returns it if the source is also an ObservableBuilder.
static <T> ObservableBuilder<T>	from(java.lang.Runnable run) Invoke the given callable on the given pool and observe its result via the returned observable.
static <T> ObservableBuilder<T>	from(java.lang.Runnable run, Scheduler pool) Invoke the given callable on the given pool and observe its result via the returned observable.
static <T> ObservableBuilder<T>	from(java.lang.Runnable run, T defaultValue) Invoke the given callable on the given pool and observe its result via the returned observable.
static <T> ObservableBuilder<T>	from(java.lang.Runnable run, T defaultValue, Scheduler pool) Invoke the given callable on the given pool and observe its result via the returned observable.
static <T> ObservableBuilder<T>	from(Scheduler scheduler, T... ts) Creates an observable sequence from the array of values and uses the given scheduler to emit these values.
static <T> ObservableBuilder<T>	from(T... ts) Creates an observable sequence from the array of values and uses the default scheduler to emit these values.
static <T> ObservableBuilder<T>	fromOriginal(java.util.Observable javaObservable) Converts the original Java Observable into an reactive-Observable builder instance.
static <T> ObservableBuilder<T>	fromPart(int start, int end, Scheduler scheduler, T... ts) Creates an observable sequence from the subarray of values and uses the given scheduler to emit these values.
static <T> ObservableBuilder<T>	fromPart(int start, int end, T... ts) Creates an observable sequence from the subarray of values and uses the default scheduler to emit these values.
static <T,U> ObservableBuilder<U>	generate(T initial, Func1<? super T,java.lang.Boolean> condition, Func1<? super T,? extends T> next, Func1<? super T,? extends U> selector) Generates a stream of Us by using a value T stream using the default pool fo the generator loop.
static <T,U> ObservableBuilder<U>	generate(T initial, Func1<? super T,java.lang.Boolean> condition, Func1<? super T,? extends T> next, Func1<? super T,? extends U> selector, Scheduler pool) Generates a stream of Us by using a value T stream.
static <T,U> ObservableBuilder<Timestamped<U>>	generateTimed(T initial, Func1<? super T,java.lang.Boolean> condition, Func1<? super T,? extends T> next, Func1<? super T,? extends U> selector, Func1<? super T,java.lang.Long> delay) Generates a stream of Us by using a value T stream.
static <T,U> ObservableBuilder<Timestamped<U>>	generateTimed(T initial, Func1<? super T,java.lang.Boolean> condition, Func1<? super T,? extends T> next, Func1<? super T,? extends U> selector, Func1<? super T,java.lang.Long> delay, Scheduler pool) Generates a stream of Us by using a value T stream.
<Key> ObservableBuilder<GroupedObservable<Key,T>>	groupBy(Func1<? super T,? extends Key> keyExtractor) Group the specified source accoring to the keys provided by the extractor function.
<U,Key> ObservableBuilder<GroupedObservable<Key,U>>	groupBy(Func1<? super T,? extends Key> keyExtractor, Func1<? super T,? extends U> valueExtractor) Group the specified source according to the keys provided by the extractor function.
<K,D> ObservableBuilder<GroupedObservable<K,T>>	groupByUntil(Func1<? super T,? extends K> keySelector, Func1<? super GroupedObservable<K,T>,? extends Observable<D>> durationSelector) Groups the source sequence of Ts until the specified duration for that group fires.
<K,D> ObservableBuilder<GroupedObservable<K,T>>	groupByUntil(Func1<? super T,? extends K> keySelector, Func1<? super GroupedObservable<K,T>,? extends Observable<D>> durationSelector, Func2<? super K,? super K,java.lang.Boolean> keyComparer) Groups the source sequence of Ts until the specified duration for that group fires.
<K,V,D> ObservableBuilder<GroupedObservable<K,V>>	groupByUntil(Func1<? super T,? extends K> keySelector, Func1<? super T,? extends V> valueSelector, Func1<? super GroupedObservable<K,V>,? extends Observable<D>> durationSelector) Groups the source sequence of Ts until the specified duration for that group fires.
<K,V,D> ObservableBuilder<GroupedObservable<K,V>>	groupByUntil(Func1<? super T,? extends K> keySelector, Func1<? super T,? extends V> valueSelector, Func1<? super GroupedObservable<K,V>,? extends Observable<D>> durationSelector, Func2<? super K,? super K,java.lang.Boolean> keyComparer) Groups the source sequence of Ts until the specified duration for that group fires.
<Right,LeftDuration,RightDuration,Result> ObservableBuilder<Result>	groupJoin(Observable<? extends Right> right, Func1<? super T,? extends Observable<LeftDuration>> leftDurationSelector, Func1<? super Right,? extends Observable<RightDuration>> rightDurationSelector, Func2<? super T,? super Observable<? extends Right>,? extends Result> resultSelector) Returns an observable which correlates two streams of values based on their time when they overlapped and groups the results.
ObservableBuilder<T>	ignoreValues() Ignores the next() messages of the source and forwards only the error() and finish() messages.
<U extends java.util.Collection<? super T>> U	into(U out) Add the elements of the sequence into the supplied collection.
ObservableBuilder<T>	invoke(Action1<? super T> action) Invoke a specific action before relaying the Ts to the observable.
ObservableBuilder<T>	invoke(Action1<? super T> onNext, Action0 onFinish) Invokes the given actions while relaying events.
ObservableBuilder<T>	invoke(Action1<? super T> onNext, Action1<? super java.lang.Throwable> onError) Invokes the given actions while relaying events.
ObservableBuilder<T>	invoke(Action1<? super T> onNext, Action1<? super java.lang.Throwable> onError, Action0 onFinish) Invokes the given actions while relaying events.
ObservableBuilder<T>	invoke(Observer<? super T> observer) Invoke a specific observer before relaying the Ts, finish() and error() to the observable.
ObservableBuilder<java.lang.Boolean>	isEmpty() Signals true if the source observable fires finish() without ever firing next().
boolean	isInstance(java.lang.Class<?> clazz) Checks if the wrapped Observable is the instance of the given class or interface according to Class.isInstance().
<Right,LeftDuration,RightDuration,Result> ObservableBuilder<Result>	join(Observable<? extends Right> right, Func1<? super T,? extends Observable<LeftDuration>> leftDurationSelector, Func1<? super Right,? extends Observable<RightDuration>> rightDurationSelector, Func2<? super T,? super Right,? extends Result> resultSelector) Returns an observable which correlates two streams of values based on their time when they overlapped.
T	last() Returns the last element of the source observable or throws NoSuchElementException if the source is empty or the wait is interrupted.
T	last(Func0<? extends T> defaultSupplier) Returns the last element of the source observable or the supplier's value if the source is empty.
T	last(T defaultValue) Returns the last element of the source observable or the default value if the source is empty.
ObservableBuilder<T>	lastAsync() Returns an observable which relays the last element of the source observable or throws a NoSuchElementException() if the source is empty.
ObservableBuilder<T>	lastAsync(Func0<? extends T> defaultSupplier) Returns an observable which relays the last element of the source observable or the supplier's value if the source is empty.
ObservableBuilder<T>	lastAsync(T defaultValue) Returns an observable which relays the last element of the source observable or the default value if the source is empty.
IterableBuilder<T>	latest() Returns an iterable which returns values on a momentary basis from the source.
<U> ObservableBuilder<U>	manySelect(Func1<? super Observable<T>,? extends Observable<U>> selector) For each of the source elements, creates a view of the source starting with the given element and calls the selector function.
<U> ObservableBuilder<U>	manySelect(Func1<? super Observable<T>,? extends U> selector, Scheduler scheduler) For each value of the source observable, it creates a view starting from that value into the source and calls the given selector function asynchronously on the given scheduler.
<U> ObservableBuilder<U>	manySelect0(Func1<? super Observable<T>,? extends U> selector) Uses the selector function on the given source observable to extract a single value and send this value to the registered observer.
ObservableBuilder<Option<T>>	materialize() Returns an observable which converts all messages to an Option value.
<U extends java.lang.Comparable<? super U>> ObservableBuilder<U>	max() Returns the maximum value encountered in the source observable onse it finish().
ObservableBuilder<T>	max(java.util.Comparator<T> comparator) Returns the maximum value encountered in the source observable onse it finish().
<Key extends java.lang.Comparable<? super Key>> ObservableBuilder<java.util.List<T>>	maxBy(Func1<? super T,? extends Key> keyExtractor) Returns an observable which provides with the list of Ts which had their keys as maximums.
<Key> ObservableBuilder<java.util.List<T>>	maxBy(Func1<? super T,? extends Key> keyExtractor, java.util.Comparator<? super Key> keyComparator) Returns an observable which provides with the list of Ts which had their keys as maximums.
ObservableBuilder<T>	merge(java.lang.Iterable<? extends Observable<? extends T>> sources) Combines the notifications of all sources.
ObservableBuilder<T>	merge(Observable<? extends T> second) Merge the events of two observable sequences.
ObservableBuilder<T>	mergeAll(Observable<? extends Observable<T>> sources) Merge the dynamic sequence of observables of T.
<U extends java.lang.Comparable<? super U>> ObservableBuilder<U>	min() Returns the minimum value encountered in the source observable onse it finish().
ObservableBuilder<T>	min(java.util.Comparator<? super T> comparator) Returns the minimum value encountered in the source observable onse it finish().
<Key extends java.lang.Comparable<? super Key>> ObservableBuilder<java.util.List<T>>	minBy(Func1<? super T,? extends Key> keyExtractor) Returns an observable which provides with the list of Ts which had their keys as minimums.
<Key> ObservableBuilder<java.util.List<T>>	minBy(Func1<T,Key> keyExtractor, java.util.Comparator<Key> keyComparator) Returns an observable which provides with the list of Ts which had their keys as minimums.
IterableBuilder<T>	mostRecent(T initialValue) Samples the latest T value coming from the source observable or the initial value when no messages arrived so far.
<U,V> Observable<V>	multicast(Func0<? extends Subject<? super T,? extends U>> subjectSelector, Func1<? super Observable<? extends U>,? extends Observable<? extends V>> selector) Multicasts the source events through the subject instantiated via the subjectSelector.
<U> ObservableBuilder<U>	multicast(Observer<? super T> observer, Observable<? extends U> observable) Returns an observable which remains connected to the source observable as long as there is at least one registration to this output observable.
ObservableBuilder<T>	never() Returns an observable which never fires.
static <T> ObservableBuilder<T>	newBuilder(Observable<T> source) Wraps the source observable into a new observable builder instance.
IterableBuilder<T>	next() Returns an iterable sequence which blocks until an element becomes available from the source.
ObservableBuilder<T>	observeOn(Scheduler pool) Wrap the given observable object in a way that any of its observers receive callbacks on the given thread pool.
<U> ObservableBuilder<U>	ofType(java.lang.Class<U> clazz) Filters the elements of the source sequence which is assignable to the provided type.
<U extends java.lang.Comparable<? super U>> ObservableBuilder<U>	orderBy() Returns an Observable which traverses the entire source Observable and creates an ordered list of elements.
ObservableBuilder<T>	orderBy(java.util.Comparator<? super T> comparator) Returns an Observable which traverses the entire source Observable and creates an ordered list of elements.
<U extends java.lang.Comparable<? super U>> ObservableBuilder<T>	orderBy(Func1<? super T,? extends U> keySelector) Returns an Observable which traverses the entire source Observable and creates an ordered list of elements.
<U> ObservableBuilder<T>	orderBy(Func1<? super T,? extends U> keySelector, java.util.Comparator<? super U> keyComparator) Returns an Observable which traverses the entire source Observable and creates an ordered list of elements.
void	print() Runs this observable and prints the values.
void	println() Runs this observable and prints the values.
ObservableBuilder<T>	prune() Returns an observable which shares all registration to the source observable and each observer will only see the last notification.
<U> ObservableBuilder<U>	prune(Func1<? super Observable<? extends T>,? extends Observable<U>> selector) Returns an observable which shares all registration to the source observable and each observer will only see the last notification.
<U> ObservableBuilder<U>	prune(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, Scheduler scheduler) Returns an observable which shares all registration to the source observable and each observer will only see the last notification.
ObservableBuilder<T>	prune(Scheduler scheduler) Returns an observable which shares all registration to the source observable and each observer will only see the last notification.
ObservableBuilder<T>	publish() Returns an observable which shares a single subscription to the underlying source.
<U> ObservableBuilder<U>	publish(Func1<? super Observable<? extends T>,? extends Observable<? extends U>> selector) Returns an observable sequence which is the result of invoking the selector on a connectable observable sequence that shares a single subscription with the underlying source observable.
<U> ObservableBuilder<U>	publish(Func1<? super Observable<? extends T>,? extends Observable<? extends U>> selector, T initialValue) Returns an observable sequence which is the result of invoking the selector on a connectable observable sequence that shares a single subscription with the underlying source observable and registering parties receive the initial value immediately.
ObservableBuilder<T>	publish(T initialValue) Returns an observable which shares a single subscription to the underlying source and starts with with the initial value.
ObservableBuilder<T>	publishLast() Returns a connectable observable which uses a single registration to the underlying source sequence containing only the last value.
<U> ObservableBuilder<U>	publishLast(Func1<? super Observable<? extends T>,? extends Observable<? extends U>> selector) Retunrs an observable that is the result of the selector invocation on a connectable observable that shares a single registration to source and returns the last event of the source.
static ObservableBuilder<java.math.BigDecimal>	range(java.math.BigDecimal start, int count, java.math.BigDecimal step) Creates an observable which generates numbers from start.
static ObservableBuilder<java.math.BigDecimal>	range(java.math.BigDecimal start, int count, java.math.BigDecimal step, Scheduler pool) Creates an observable which generates BigDecimal numbers from start.
static ObservableBuilder<java.math.BigInteger>	range(java.math.BigInteger start, java.math.BigInteger count) Creates an observable which generates numbers from start.
static ObservableBuilder<java.math.BigInteger>	range(java.math.BigInteger start, java.math.BigInteger count, Scheduler pool) Creates an observable which generates BigInteger numbers from start.
static ObservableBuilder<java.lang.Double>	range(double start, int count, double step) Creates an observable which generates numbers from start.
static ObservableBuilder<java.lang.Double>	range(double start, int count, double step, Scheduler pool) Creates an observable which produces Double values from start in count amount and each subsequent element has a difference of step.
static ObservableBuilder<java.lang.Float>	range(float start, int count, float step) Creates an observable which generates numbers from start.
static ObservableBuilder<java.lang.Float>	range(float start, int count, float step, Scheduler pool) Creates an observable which produces Float values from start in count amount and each subsequent element has a difference of step.
static ObservableBuilder<java.lang.Integer>	range(int start, int count) Creates an observable which generates numbers from start.
static ObservableBuilder<java.lang.Integer>	range(int start, int count, Scheduler pool) Creates an observable which generates numbers from start.
static ObservableBuilder<java.lang.Long>	range(long start, long count) Creates an observable which generates numbers from start.
static ObservableBuilder<java.lang.Long>	range(long start, long count, Scheduler pool) Creates an observable which generates numbers from start.
ObservableBuilder<T>	refCount() Returns an observable sequence which connects to the source for the first registered party and stays connected to the source as long as there is at least one registered party to it.
java.io.Closeable	register(java.util.Observer javaObserver) Registers a java-observer with this reactive-observable instance.
java.io.Closeable	register(Observer<? super T> observer) Registers an observer for the notification of Ts.
ObservableBuilder<T>	registerOn(Scheduler pool) Wrap the given observable into an new Observable instance, which calls the original register() method on the supplied pool.
ObservableBuilder<T>	relayUntil(Func0<java.lang.Boolean> condition) Relay values of T while the given condition does not hold.
ObservableBuilder<T>	relayWhile(Func0<java.lang.Boolean> condition) Relay the stream of Ts until condition turns into false.
ObservableBuilder<T>	removeTimeInterval() Unwrap the values within a timeinterval observable to its normal value.
ObservableBuilder<T>	removeTimestamped() Unwrap the values within a timestamped observable to its normal value.
ObservableBuilder<T>	repeat() Repeat the source observable indefinitely.
static <T> ObservableBuilder<T>	repeat(Func0<? extends T> func) Creates an observable which repeatedly calls the given function which generates the Ts indefinitely.
static <T> ObservableBuilder<T>	repeat(Func0<? extends T> func, int count) Creates an observable which repeatedly calls the given function count times to generate Ts and runs on the default pool.
static <T> ObservableBuilder<T>	repeat(Func0<? extends T> func, int count, Scheduler pool) Creates an observable which repeatedly calls the given function count times to generate Ts and runs on the given pool.
static <T> ObservableBuilder<T>	repeat(Func0<? extends T> func, Scheduler pool) Creates an observable which repeatedly calls the given function which generates the Ts indefinitely.
ObservableBuilder<T>	repeat(int count) Repeat the source observable count times.
static <T> ObservableBuilder<T>	repeat(T value) Creates an observable which repeates the given value indefinitely and runs on the default pool.
static <T> ObservableBuilder<T>	repeat(T value, int count) Creates an observable which repeates the given value count times and runs on the default pool.
static <T> ObservableBuilder<T>	repeat(T value, int count, Scheduler pool) Creates an observable which repeates the given value count times and runs on the given pool.
static <T> ObservableBuilder<T>	repeat(T value, Scheduler pool) Creates an observable which repeates the given value indefinitely and runs on the given pool.
ObservableBuilder<T>	replay() Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, int bufferSize) Creates an observable which shares the source observable and replays the buffered source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, int bufferSize, long timeSpan, java.util.concurrent.TimeUnit unit) Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, int bufferSize, long timeSpan, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, int bufferSize, Scheduler scheduler) Creates an observable which shares the source observable returned by the selector and replays all source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, long timeSpan, java.util.concurrent.TimeUnit unit) Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<? extends T>,? extends Observable<U>> selector, long timeSpan, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
<U> ObservableBuilder<U>	replay(Func1<? super Observable<T>,? extends Observable<U>> selector) Returns the observable sequence for the supplied source observable by invoking the selector function with it.
ObservableBuilder<T>	replay(int bufferSize) Creates an observable which shares the source observable and replays the buffered source Ts to any of the registering observers.
ObservableBuilder<T>	replay(int bufferSize, long timeSpan, java.util.concurrent.TimeUnit unit) Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers.
ObservableBuilder<T>	replay(int bufferSize, long timeSpan, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers.
ObservableBuilder<T>	replay(int bufferSize, Scheduler scheduler) Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
ObservableBuilder<T>	replay(long timeSpan, java.util.concurrent.TimeUnit unit) Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
ObservableBuilder<T>	replay(long timeSpan, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
ObservableBuilder<T>	replay(Scheduler scheduler) Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.
ObservableBuilder<T>	resumeAlways(java.lang.Iterable<? extends Observable<? extends T>> sources) Returns an observable which listens to elements from a source until it signals an error() or finish() and continues with the next observable.
ObservableBuilder<T>	resumeConditionally(Func1<? super java.lang.Throwable,? extends Observable<? extends T>> handler) Continues the observable sequence in case of exception whith the sequence provided by the function for that particular exception.
ObservableBuilder<T>	resumeOnError(java.lang.Iterable<? extends Observable<? extends T>> sources) It tries to submit the values of first observable, but when it throws an exeption, the next observable within source is used further on.
ObservableBuilder<T>	retry() Restarts the observation until the source observable terminates normally.
ObservableBuilder<T>	retry(int count) Restarts the observation until the source observable terminates normally or the count retry count was used up.
void	run() Blocks until the observable calls finish() or error().
void	run(Action1<? super T> action) Blocks until the observable calls finish() or error().
void	run(Observer<? super T> observer) Blocks until the observable calls finish() or error().
ObservableBuilder<T>	sample(long time, java.util.concurrent.TimeUnit unit) Periodically sample the given source observable, which means tracking the last value of the observable and periodically submitting it to the output observable.
ObservableBuilder<T>	sample(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Periodically sample the given source observable, which means tracking the last value of the observable and periodically submitting it to the output observable.
<U> ObservableBuilder<T>	sample(Observable<? extends U> sampler) Samples the observable sequence when the other sequence fires an event.
ObservableBuilder<T>	scan(Func2<? super T,? super T,? extends T> accumulator) Creates an observable which accumultates the given source and submits each intermediate results to its subscribers.
ObservableBuilder<T>	scan(T seed, Func2<? super T,? super T,? extends T> accumulator) Creates an observable which accumultates the given source and submits each intermediate results to its subscribers.
<U> ObservableBuilder<U>	select(Func1<? super T,? extends U> mapper) Use the mapper to transform the T source into an U source.
<U> ObservableBuilder<U>	select(Func2<? super T,? super java.lang.Integer,? extends U> selector) Transforms the elements of the source observable into Us by using a selector which receives an index indicating how many elements have been transformed this far.
<U> ObservableBuilder<U>	selectLong(Func2<? super T,? super java.lang.Long,? extends U> selector) Transforms the elements of the source observable into Us by using a selector which receives a long index indicating how many elements have been transformed this far.
<U> ObservableBuilder<U>	selectMany(Func1<? super T,? extends Observable<? extends U>> selector) Transform the given source of Ts into Us in a way that the selector might return an observable ofUs for a single T.
<U,V> ObservableBuilder<V>	selectMany(Func1<? super T,? extends Observable<? extends U>> collectionSelector, Func2<? super T,? super U,? extends V> resultSelector) Creates an observable in which for each of Ts an observable of Vs are requested which in turn will be transformed by the resultSelector for each pair of T and V giving an U.
<U> ObservableBuilder<U>	selectMany(Observable<? extends U> provider) Creates an observable of Us in a way when a source T arrives, the observable of Us is completely drained into the output.
<U> ObservableBuilder<U>	selectManyIterable(Func1<? super T,? extends java.lang.Iterable<? extends U>> selector) Transform the given source of Ts into Us in a way that the selector might return zero to multiple elements of Us for a single T.
<U,V> Observable<V>	selectManyIterable(Func1<? super T,? extends java.lang.Iterable<? extends U>> selector, Func2<? super T,? super U,? extends V> resultSelector) Transform the given source of Ts into Us in a way that the selector might return zero to multiple elements of Us for a single T.
ObservableBuilder<java.lang.Boolean>	sequenceEqual(Observable<? extends T> second) Compares two sequences and returns whether they are produce the same elements in terms of the null-safe object equality.
ObservableBuilder<java.lang.Boolean>	sequenceEqual(Observable<? extends T> second, Func2<? super T,? super T,java.lang.Boolean> comparer) Compares two sequences and returns whether they are produce the same elements in terms of the comparer function.
T	single() Returns the single element of the given observable source.
T	single(Func0<? extends T> defaultSupplier) Returns the single element of the given observable source, returns the supplier's value if the source is empty or throws a TooManyElementsException in case the source has more than one item.
T	single(T defaultValue) Returns the single element of the given observable source, returns the default if the source is empty or throws a TooManyElementsException in case the source has more than one item.
ObservableBuilder<T>	singleAsync() Returns the only element of the source or throws NoSuchElementException if the source is empty or TooManyElementsException if it contains more than one elements.
ObservableBuilder<T>	singleAsync(Func0<? extends T> defaultSupplier) Returns the only element of the source, returns the supplier's value if the source is empty or TooManyElementsException if it contains more than one elements.
ObservableBuilder<T>	singleAsync(T defaultValue) Returns the only element of the source, returns the default value if the source is empty or TooManyElementsException if it contains more than one elements.
ObservableBuilder<T>	skip(int count) Skips the given amount of next() messages from source and relays the rest.
ObservableBuilder<T>	skip(long time, java.util.concurrent.TimeUnit unit) Skips elements of the source observable for the specified amount of time.
ObservableBuilder<T>	skip(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Skips elements of the source observable for the specified amount of time.
ObservableBuilder<T>	skipLast(int count) Skips the last count elements from the source observable.
ObservableBuilder<T>	skipLast(long time, java.util.concurrent.TimeUnit unit) Skips the elements from the end for the specified amount of time.
<U> ObservableBuilder<T>	skipUntil(Observable<? extends U> signaller) Skip the source elements until the signaller sends its first element.
ObservableBuilder<T>	skipWhile(Func1<? super T,java.lang.Boolean> condition) Skips the Ts from source while the specified condition returns true.
ObservableBuilder<T>	skipWhile(Func2<? super T,? super java.lang.Integer,java.lang.Boolean> condition) Skips the Ts from source while the specified indexed condition returns true.
ObservableBuilder<T>	skipWhileLong(Func2<? super T,? super java.lang.Long,java.lang.Boolean> condition) Skips the Ts from source while the specified long indexed condition returns true.
ObservableBuilder<T>	startWith(java.lang.Iterable<? extends T> values) Start with the given iterable of values before relaying the Ts from the source.
ObservableBuilder<T>	startWith(java.lang.Iterable<? extends T> values, Scheduler pool) Start with the given iterable of values before relaying the Ts from the source.
ObservableBuilder<T>	startWith(Scheduler pool, T... values) Start with the given iterable of values before relaying the Ts from the source.
ObservableBuilder<T>	startWith(T... values) Start with the given iterable of values before relaying the Ts from the source.
ObservableBuilder<java.math.BigDecimal>	sumBigDecimal() Computes and signals the sum of the values of the BigDecimal source.
ObservableBuilder<java.math.BigInteger>	sumBigInteger() Computes and signals the sum of the values of the BigInteger source.
ObservableBuilder<java.lang.Double>	sumDouble() Computes and signals the sum of the values of the Double source.
ObservableBuilder<java.lang.Float>	sumFloat() Computes and signals the sum of the values of the Float source.
ObservableBuilder<java.lang.Integer>	sumInt() Computes and signals the sum of the values of the Integer source.
ObservableBuilder<java.lang.Double>	sumIntAsDouble() Computes and signals the sum of the values of the Integer source by using a double intermediate representation.
ObservableBuilder<java.lang.Long>	sumLong() Computes and signals the sum of the values of the Long source.
ObservableBuilder<java.lang.Double>	sumLongAsDouble() Computes and signals the sum of the values of the Long sourceby using a double intermediate representation.
ObservableBuilder<T>	switchToNext(Observable<? extends Observable<? extends T>> sources) Returns an observer which relays Ts from the source observables in a way, when a new inner observable comes in, the previous one is deregistered and the new one is continued with.
ObservableBuilder<T>	synchronize() Returns an observable sequence which ensures that the registering observers follow the general contract on observables by serializing access to the event methods.
ObservableBuilder<T>	take(int count) Creates an observable which takes the specified number of Ts from the source, unregisters and completes.
ObservableBuilder<T>	take(int count, Scheduler scheduler) Creates an observable which takes the specified number of Ts from the source, unregisters and completes.
ObservableBuilder<T>	take(long time, java.util.concurrent.TimeUnit unit) Takes the elements from the source sequence until the time runs out.
ObservableBuilder<T>	take(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Takes the elements from the source sequence until the time runs out.
ObservableBuilder<T>	takeLast(int count) Returns an observable which returns the last count elements from the source observable.
ObservableBuilder<T>	takeLast(int count, Scheduler pool) Returns an observable which returns the last count elements from the source observable and emits them from the specified scheduler pool.
ObservableBuilder<T>	takeLast(long time, java.util.concurrent.TimeUnit unit) Skips the elements from the end for the specified amount of time.
ObservableBuilder<T>	takeLast(long time, java.util.concurrent.TimeUnit unit, Scheduler drainPool) Skips the elements from the end for the specified amount of time.
ObservableBuilder<java.util.List<T>>	takeLastBuffer(int count) Returns an observable which returns the last count elements from the source observable and returns it as a single list.
ObservableBuilder<java.util.List<T>>	takeLastBuffer(long time, java.util.concurrent.TimeUnit unit) Skips the elements from the end for the specified amount of time as one list.
ObservableBuilder<java.util.List<T>>	takeLastBuffer(long time, java.util.concurrent.TimeUnit unit, Scheduler drainPool) Skips the elements from the end for the specified amount of time as one list.
<U> ObservableBuilder<T>	takeUntil(Observable<U> signaller) Creates an observable which takes values from the source until the signaller produces a value.
ObservableBuilder<T>	takeWhile(Func1<? super T,java.lang.Boolean> predicate) Creates an observable which takes values from source until the predicate returns false for the current element, then skips the remaining values.
ObservableBuilder<T>	takeWhile(Func2<? super T,? super java.lang.Integer,java.lang.Boolean> predicate) Creates an observable which takes values from source until the indexed predicate returns false for the current element, then skips the remaining values.
ObservableBuilder<T>	takeWhileLong(Func2<? super T,? super java.lang.Long,java.lang.Boolean> predicate) Creates an observable which takes values from source until the long indexed predicate returns false for the current element, then skips the remaining values.
<U> ObservableBuilder<T>	throttle(Func1<? super T,? extends Observable<U>> durationSelector) Fires the last event from the source observable if no events are fired during a selector-returned observable window.
ObservableBuilder<T>	throttle(long delay, java.util.concurrent.TimeUnit unit) Creates and observable which fires the last value from source when the given timespan elapsed without a new value occurring from the source.
ObservableBuilder<T>	throttle(long delay, java.util.concurrent.TimeUnit unit, Scheduler pool) Creates and observable which fires the last value from source when the given timespan elapsed without a new value occurring from the source.
static <T> ObservableBuilder<T>	throwException(java.lang.Throwable ex) Creates an observable which instantly sends the exception to its subscribers while running on the default pool.
static <T> ObservableBuilder<T>	throwException(java.lang.Throwable ex, Scheduler pool) Creates an observable which instantly sends the exception to its subscribers while running on the given pool.
static ObservableBuilder<java.lang.Long>	tick(long start, long end, long delay, java.util.concurrent.TimeUnit unit) Returns an observable which produces an ordered sequence of numbers with the specified delay.
static ObservableBuilder<java.lang.Long>	tick(long start, long end, long delay, java.util.concurrent.TimeUnit unit, Scheduler pool) Returns an observable which produces an ordered sequence of numbers with the specified delay.
static ObservableBuilder<java.lang.Long>	tick(long delay, java.util.concurrent.TimeUnit unit) Returns an observable which produces an ordered sequence of numbers with the specified delay.
<V> ObservableBuilder<T>	timeout(Func1<? super T,? extends Observable<V>> timeoutSelector) Applies a timeout to each element of the sequence or throws a TimeoutException if an element is not followed by another within the firing of the timeout selector's observable sequence.
<V> ObservableBuilder<T>	timeout(Func1<? super T,? extends Observable<V>> timeoutSelector, Observable<? extends T> other) Applies a timeout to each element in the source sequence, for each element a separate window is opened in the form of observable sequence.
ObservableBuilder<T>	timeout(long time, java.util.concurrent.TimeUnit unit) Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it singlals a java.util.concurrent.TimeoutException.
ObservableBuilder<T>	timeout(long time, java.util.concurrent.TimeUnit unit, Observable<? extends T> other) Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it switches to the other observable.
ObservableBuilder<T>	timeout(long time, java.util.concurrent.TimeUnit unit, Observable<? extends T> other, Scheduler pool) Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it switches to the other observable.
ObservableBuilder<T>	timeout(long time, java.util.concurrent.TimeUnit unit, Scheduler pool) Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it singlals a java.util.concurrent.TimeoutException.
<U,V> ObservableBuilder<T>	timeout(Observable<U> firstTimeout, Func1<? super T,? extends Observable<V>> timeoutSelector) Applies a timeout to each element of the sequence or throws a TimeoutException if an element is not followed by another within the firing of the timeout selector's observable sequence.
<U,V> ObservableBuilder<T>	timeout(Observable<U> firstTimeout, Func1<? super T,? extends Observable<V>> timeoutSelector, Observable<? extends T> other) Applies a timeout to each element in the source sequence, starting with the timeout from the firsTimeout observabe, then, for each element a separate window is opened in the form of observable sequence.
ObservableBuilder<T>	timeoutFinish(long time, java.util.concurrent.TimeUnit unit) Creates an observable which finishes its observers after the specified amount of time if no error or finish events appeared till then.
ObservableBuilder<T>	timeoutFinish(long time, java.util.concurrent.TimeUnit unit, Scheduler scheduler) Creates an observable which finishes its observers after the specified amount of time if no error or finish events appeared till then.
ObservableBuilder<java.lang.Object[]>	toArray() Creates an array from the observable sequence elements.
ObservableBuilder<T[]>	toArray(T[] a) Creates an array from the observable sequence elements by using the given array for the template to create a dynamicly typed array of Ts.
IterableBuilder<T>	toIterable() Converts this observable into an iterable builder.
ObservableBuilder<java.util.List<T>>	toList() Collect the elements of the source observable into a single list.
<K> ObservableBuilder<java.util.Map<K,T>>	toMap(Func1<? super T,? extends K> keySelector) Maps the given source of Ts by using the key extractor and returns a single Map of them.
<K,V> ObservableBuilder<java.util.Map<K,V>>	toMap(Func1<? super T,? extends K> keySelector, Func1<? super T,? extends V> valueSelector) Maps the given source of Ts by using the key extractor and returns a single Map of them.
<K,V> ObservableBuilder<java.util.Map<K,V>>	toMap(Func1<? super T,? extends K> keySelector, Func1<? super T,? extends V> valueSelector, Func2<? super K,? super K,java.lang.Boolean> keyComparer) Maps the given source of Ts by using the key and value extractor and returns a single Map of them.
<K> ObservableBuilder<java.util.Map<K,T>>	toMap(Func1<? super T,? extends K> keySelector, Func2<? super K,? super K,java.lang.Boolean> keyComparer) Maps the given source of Ts by using the key extractor and returns a single Map of them.
<K> ObservableBuilder<java.util.Map<K,java.util.Collection<T>>>	toMultiMap(Func1<? super T,? extends K> keySelector, Func0<? extends java.util.Collection<T>> collectionSupplier) Maps the given source of Ts by using the key extractor and returns a single multi-map of them.
<K> ObservableBuilder<java.util.Map<K,java.util.Collection<T>>>	toMultiMap(Func1<? super T,? extends K> keySelector, Func0<? extends java.util.Collection<T>> collectionSupplier, Func2<? super K,? super K,java.lang.Boolean> keyComparer) Maps the given source of Ts by using the key extractor and returns a single multi-map of them.
<K,V> ObservableBuilder<java.util.Map<K,java.util.Collection<V>>>	toMultiMap(Func1<? super T,? extends K> keySelector, Func0<? extends java.util.Collection<V>> collectionSupplier, Func1<? super T,? extends V> valueSelector) Maps the given source of Ts by using the key and value extractor and returns a single multi-map of them.
<K,V> ObservableBuilder<java.util.Map<K,java.util.Collection<V>>>	toMultiMap(Func1<? super T,? extends K> keySelector, Func0<? extends java.util.Collection<V>> collectionSupplier, Func1<? super T,? extends V> valueSelector, Func2<? super K,? super K,java.lang.Boolean> keyComparer) Maps the given source of Ts by using the key and value extractor and returns a single multi-map of them.
java.util.Observable	toOriginalObservable()
Observable<T>	unwrap()
ObservableBuilder<T>	where(Func0<Func2<? super T,? super java.lang.Integer,java.lang.Boolean>> clauseFactory) Creates a filtered observable where only Ts are relayed which satisfy the clause.
ObservableBuilder<T>	where(Func1<? super T,java.lang.Boolean> clause) Creates a filtered observable where only Ts are relayed which satisfy the clause.
ObservableBuilder<T>	where(Func2<? super T,? super java.lang.Integer,java.lang.Boolean> clause) Creates a filtered observable where only Ts are relayed which satisfy the clause.
ObservableBuilder<T>	whereLong(Func2<? super T,? super java.lang.Long,java.lang.Boolean> clause) Creates a filtered observable where only Ts are relayed which satisfy the clause.
ObservableBuilder<T>	whileDo(Func0<java.lang.Boolean> condition) Repeatedly registers with the source observable if the condition holds on registration.
<U> ObservableBuilder<Observable<T>>	window(Func0<? extends Observable<U>> windowClosing) Splits the source stream into separate observables once the windowClosing fires an event.
ObservableBuilder<Observable<T>>	window(int size) Project the source sequence to non-overlapping windows with the given size.
Observable<Observable<T>>	window(int size, int skip) Project the source sequence to potentially overlapping windows whose start is determined by skip and lengths by size.
ObservableBuilder<Observable<T>>	window(int size, long timespan, java.util.concurrent.TimeUnit unit) Projects each element into a window that is completed by either its full or the specified amount of time elapsed.
ObservableBuilder<Observable<T>>	window(int size, long timespan, java.util.concurrent.TimeUnit unit, Scheduler pool) Projects each element into a window that is completed by either its full or the specified amount of time elapsed.
ObservableBuilder<Observable<T>>	window(long timespan, long timeshift, java.util.concurrent.TimeUnit unit) Projects elements from the source observable into zero or more windows which are produced based on timing information.
ObservableBuilder<Observable<T>>	window(long timespan, long timeshift, java.util.concurrent.TimeUnit unit, Scheduler pool) Projects elements from the source observable into zero or more windows which are produced based on timing information and run on the specified scheduler.
ObservableBuilder<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit) Projects elements from the source observable into distinct windows which are produced based on timing information.
ObservableBuilder<Observable<T>>	window(long timespan, java.util.concurrent.TimeUnit unit, Scheduler pool) Projects elements from the source observable into zero or more windows which are produced based on timing information and run on the specified scheduler.
<U,V> ObservableBuilder<Observable<T>>	window(Observable<? extends U> windowOpening, Func1<? super U,? extends Observable<V>> windowClosing) Splits the source stream into separate observables by starting at windowOpening events and closing at windowClosing events.
<U> Observable<Observable<T>>	window(Observable<U> boundary) Projects the source elements into a non-overlapping consecutive windows.
<U,V> ObservableBuilder<V>	zip(java.lang.Iterable<? extends U> right, Func2<? super T,? super U,? extends V> selector) Creates an observable which waits for events from left and combines it with the next available value from the right iterable, applies the selector function and emits the resulting T.
<U,V> ObservableBuilder<V>	zip(Observable<? extends U> right, Func2<T,U,V> selector) Creates an observable which waits for events from left and combines it with the next available value from the right observable, applies the selector function and emits the resulting T.
ObservableBuilder<java.util.List<T>>	zipFirst(T constant) Combine a stream of Ts with a constant T whenever the src fires.
ObservableBuilder<java.util.List<T>>	zipLast(java.util.List<? extends Observable<? extends T>> srcs) Combine the incoming Ts of the various observables into a single list of Ts like using Reactive.zip() on more than two sources.
ObservableBuilder<java.util.List<T>>	zipLast(T constant) Combine a constant T with a stream of Ts whenever the src fires.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

o

@Nonnull
protected final Observable<T> o

The backed observable.

Constructor Detail

ObservableBuilder

protected ObservableBuilder(@Nonnull
                            Observable<T> source)

Constructor.

Parameters:

source - the source sequence

Method Detail

defer

@Nonnull
public static <T> ObservableBuilder<T> defer(@Nonnull
                                                       Func0<? extends Observable<? extends T>> observableFactory)

The returned observable invokes the observableFactory whenever an observer tries to subscribe to it.

Type Parameters:

T - the element type

Parameters:

observableFactory - the factory which is responsivle to create a source observable.

Returns:

the result observable

from

@Nonnull
public static ObservableBuilder<java.lang.Void> from(@Nonnull
                                                               Action0 action)

Invokes the action asynchronously on the given pool and relays its finish() or error() messages.

Parameters:

action - the action to invoke

Returns:

the observable

from

@Nonnull
public static ObservableBuilder<java.lang.Void> from(@Nonnull
                                                               Action0 action,
                                                               @Nonnull
                                                               Scheduler pool)

Invokes the action asynchronously on the given pool and relays its finish() or error() messages.

Parameters:

action - the action to invoke

pool - the pool where the action should run

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.util.concurrent.Callable<? extends T> call)

Invoke the given callable on the default pool and observe its result via the returned observable. Any exception thrown by the callable is relayed via the error() message.

Type Parameters:

T - the return type

Parameters:

call - the callable

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.util.concurrent.Callable<? extends T> call,
                                                      @Nonnull
                                                      Scheduler pool)

Invoke the given callable on the given pool and observe its result via the returned observable. Any exception thrown by the callable is relayed via the error() message.

Type Parameters:

T - the return type

Parameters:

call - the callable

pool - the thread pool

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      Func0<? extends T> func)

Invokes the function asynchronously on the default pool and relays its result followed by a finish. Exceptions are relayed as well.

Type Parameters:

T - the function return type

Parameters:

func - the function

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      Func0<? extends T> func,
                                                      @Nonnull
                                                      Scheduler pool)

Invokes the function asynchronously on the given pool and relays its result followed by a finish. Exceptions are relayed as well.

Type Parameters:

T - the function return type

Parameters:

func - the function

pool - the pool where the action should run

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.lang.Iterable<? extends T> source)

Creates an observable builder from the source sequence by using the default scheduler to emit the values.

Type Parameters:

T - the element type

Parameters:

source - the source iterable

Returns:

the created observable builder

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.lang.Iterable<? extends T> source,
                                                      @Nonnull
                                                      Scheduler scheduler)

Creates an observable builder from the source sequence and uses the given schduler to emit the values.

Type Parameters:

T - the element type

Parameters:

source - the source iterable

scheduler - the scheduler to emit the values

Returns:

the created observable builder

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      Observable<T> source)

Wraps the supplied observable sequence into an observable builder or returns it if the source is also an ObservableBuilder.

Type Parameters:

T - the element type

Parameters:

source - the source observable

Returns:

the created observable builder

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.lang.Runnable run)

Invoke the given callable on the given pool and observe its result via the returned observable. Any exception thrown by the callable is relayed via the error() message.

Type Parameters:

T - the return type

Parameters:

run - the runnable

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.lang.Runnable run,
                                                      @Nonnull
                                                      Scheduler pool)

Invoke the given callable on the given pool and observe its result via the returned observable. Any exception thrown by the callable is relayed via the error() message.

Type Parameters:

T - the return type

Parameters:

run - the runnable

pool - the thread pool

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.lang.Runnable run,
                                                      T defaultValue)

Invoke the given callable on the given pool and observe its result via the returned observable. Any exception thrown by the callable is relayed via the error() message.

Type Parameters:

T - the return type

Parameters:

run - the runnable

defaultValue - the value to return when the Runnable completes

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      java.lang.Runnable run,
                                                      T defaultValue,
                                                      @Nonnull
                                                      Scheduler pool)

Invoke the given callable on the given pool and observe its result via the returned observable. Any exception thrown by the callable is relayed via the error() message.

Type Parameters:

T - the return type

Parameters:

run - the runnable

pool - the thread pool

defaultValue - the value to return by default

Returns:

the observable

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      Scheduler scheduler,
                                                      @Nonnull
                                                      T... ts)

Creates an observable sequence from the array of values and uses the given scheduler to emit these values.

Type Parameters:

T - the element type

Parameters:

scheduler - the scheduler to emit the values

ts - the element array

Returns:

the created observable builder

from

@Nonnull
public static <T> ObservableBuilder<T> from(@Nonnull
                                                      T... ts)

Creates an observable sequence from the array of values and uses the default scheduler to emit these values.

Type Parameters:

T - the element type

Parameters:

ts - the element array

Returns:

the created observable builder

fromOriginal

@Nonnull
public static <T> ObservableBuilder<T> fromOriginal(@Nonnull
                                                              java.util.Observable javaObservable)

Converts the original Java Observable into an reactive-Observable builder instance. Since Java Observables had no concept of error and termination, and were considered active observable, the returned reactive-observable never terminates or throws an error.

Note that since java-observables are not generic, ClassCastException might occur if the transmitted value has incompatible class.

Remark: named as fromOriginal to avoid casts to java- or reactive observable when using a hybrid source.

Type Parameters:

T - the element type

Parameters:

javaObservable - the java observable to be used

Returns:

the new observable builder

fromPart

@Nonnull
public static <T> ObservableBuilder<T> fromPart(int start,
                                                          int end,
                                                          @Nonnull
                                                          Scheduler scheduler,
                                                          @Nonnull
                                                          T... ts)

Creates an observable sequence from the subarray of values and uses the given scheduler to emit these values.

Type Parameters:

T - the element type

Parameters:

start - the start index inclusive

end - the end index exclusive

scheduler - the scheduler to emit the values

ts - the element array

Returns:

the created observable builder

fromPart

@Nonnull
public static <T> ObservableBuilder<T> fromPart(int start,
                                                          int end,
                                                          @Nonnull
                                                          T... ts)

Creates an observable sequence from the subarray of values and uses the default scheduler to emit these values.

Type Parameters:

T - the element type

Parameters:

start - the start index inclusive

end - the end index exclusive

ts - the element array

Returns:

the created observable builder

generate

@Nonnull
public static <T,U> ObservableBuilder<U> generate(T initial,
                                                            @Nonnull
                                                            Func1<? super T,java.lang.Boolean> condition,
                                                            @Nonnull
                                                            Func1<? super T,? extends T> next,
                                                            @Nonnull
                                                            Func1<? super T,? extends U> selector)

Generates a stream of Us by using a value T stream using the default pool fo the generator loop. If T = int and U is double, this would be seen as for (int i = 0; i < 10; i++) { yield return i / 2.0; }

Type Parameters:

T - the type of the generator values

U - the type of the observed values

Parameters:

initial - the initial generator value

condition - the condition that must hold to continue generating Ts

next - the function that computes the next value of T

selector - the selector which turns Ts into Us.

Returns:

the observable

generate

@Nonnull
public static <T,U> ObservableBuilder<U> generate(T initial,
                                                            @Nonnull
                                                            Func1<? super T,java.lang.Boolean> condition,
                                                            @Nonnull
                                                            Func1<? super T,? extends T> next,
                                                            @Nonnull
                                                            Func1<? super T,? extends U> selector,
                                                            @Nonnull
                                                            Scheduler pool)

Generates a stream of Us by using a value T stream. If T = int and U is double, this would be seen as for (int i = 0; i < 10; i++) { yield return i / 2.0; }

Type Parameters:

T - the type of the generator values

U - the type of the observed values

Parameters:

initial - the initial generator value

condition - the condition that must hold to continue generating Ts

next - the function that computes the next value of T

selector - the selector which turns Ts into Us.

pool - the thread pool where the generation loop should run.

Returns:

the observable

generateTimed

@Nonnull
public static <T,U> ObservableBuilder<Timestamped<U>> generateTimed(T initial,
                                                                              @Nonnull
                                                                              Func1<? super T,java.lang.Boolean> condition,
                                                                              @Nonnull
                                                                              Func1<? super T,? extends T> next,
                                                                              @Nonnull
                                                                              Func1<? super T,? extends U> selector,
                                                                              @Nonnull
                                                                              Func1<? super T,java.lang.Long> delay)

Generates a stream of Us by using a value T stream. If T = int and U is double, this would be seen as for (int i = 0; i < 10; i++) { sleep(time); yield return i / 2.0; }

Type Parameters:

T - the type of the generator values

U - the type of the observed values

Parameters:

initial - the initial generator value

condition - the condition that must hold to continue generating Ts

next - the function that computes the next value of T

selector - the selector which turns Ts into Us.

delay - the selector which tells how much to wait before releasing the next U

Returns:

the observable

generateTimed

@Nonnull
public static <T,U> ObservableBuilder<Timestamped<U>> generateTimed(T initial,
                                                                              @Nonnull
                                                                              Func1<? super T,java.lang.Boolean> condition,
                                                                              @Nonnull
                                                                              Func1<? super T,? extends T> next,
                                                                              @Nonnull
                                                                              Func1<? super T,? extends U> selector,
                                                                              @Nonnull
                                                                              Func1<? super T,java.lang.Long> delay,
                                                                              @Nonnull
                                                                              Scheduler pool)

Generates a stream of Us by using a value T stream. If T = int and U is double, this would be seen as for (int i = 0; i < 10; i++) { sleep(time); yield return i / 2.0; }

Type Parameters:

T - the type of the generator values

U - the type of the observed values

Parameters:

initial - the initial generator value

condition - the condition that must hold to continue generating Ts

next - the function that computes the next value of T

selector - the selector which turns Ts into Us.

delay - the selector which tells how much to wait (in milliseconds) before releasing the next U

pool - the scheduled pool where the generation loop should run.

Returns:

the observable

newBuilder

@Nonnull
public static <T> ObservableBuilder<T> newBuilder(@Nonnull
                                                            Observable<T> source)

Wraps the source observable into a new observable builder instance.

Type Parameters:

T - the element type

Parameters:

source - the source obbservable

Returns:

the new observable builder

range

@Nonnull
public static ObservableBuilder<java.math.BigDecimal> range(@Nonnull
                                                                      java.math.BigDecimal start,
                                                                      int count,
                                                                      @Nonnull
                                                                      java.math.BigDecimal step)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

step - the stepping

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.math.BigDecimal> range(@Nonnull
                                                                      java.math.BigDecimal start,
                                                                      int count,
                                                                      @Nonnull
                                                                      java.math.BigDecimal step,
                                                                      @Nonnull
                                                                      Scheduler pool)

Creates an observable which generates BigDecimal numbers from start.

Parameters:

start - the start value.

count - the count

step - the stepping

pool - the execution thread pool.

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.math.BigInteger> range(@Nonnull
                                                                      java.math.BigInteger start,
                                                                      @Nonnull
                                                                      java.math.BigInteger count)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.math.BigInteger> range(@Nonnull
                                                                      java.math.BigInteger start,
                                                                      @Nonnull
                                                                      java.math.BigInteger count,
                                                                      @Nonnull
                                                                      Scheduler pool)

Creates an observable which generates BigInteger numbers from start.

Parameters:

start - the start value.

count - the count

pool - the execution thread pool.

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.lang.Double> range(double start,
                                                                  int count,
                                                                  double step)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

step - the stepping

Returns:

the observable

range

public static ObservableBuilder<java.lang.Double> range(double start,
                                                        int count,
                                                        double step,
                                                        @Nonnull
                                                        Scheduler pool)

Creates an observable which produces Double values from start in count amount and each subsequent element has a difference of step.

Parameters:

start - the starting value

count - how many values to produce

step - the incrementation amount

pool - the pool where to emit the values

Returns:

the observable of float

range

@Nonnull
public static ObservableBuilder<java.lang.Float> range(float start,
                                                                 int count,
                                                                 float step)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

step - the stepping

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.lang.Float> range(float start,
                                                                 int count,
                                                                 float step,
                                                                 @Nonnull
                                                                 Scheduler pool)

Creates an observable which produces Float values from start in count amount and each subsequent element has a difference of step.

Parameters:

start - the starting value

count - how many values to produce

step - the incrementation amount

pool - the pool where to emit the values

Returns:

the observable of float

range

@Nonnull
public static ObservableBuilder<java.lang.Integer> range(int start,
                                                                   int count)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.lang.Integer> range(int start,
                                                                   int count,
                                                                   @Nonnull
                                                                   Scheduler pool)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

pool - the execution thread pool.

Returns:

the observable

range

@Nonnull
public static ObservableBuilder<java.lang.Long> range(long start,
                                                                long count)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

Returns:

the observable

Since:

0.97

range

@Nonnull
public static ObservableBuilder<java.lang.Long> range(long start,
                                                                long count,
                                                                @Nonnull
                                                                Scheduler pool)

Creates an observable which generates numbers from start.

Parameters:

start - the start value.

count - the count

pool - the execution thread pool.

Returns:

the observable

Since:

0.97

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(@Nonnull
                                                        Func0<? extends T> func)

Creates an observable which repeatedly calls the given function which generates the Ts indefinitely. The generator runs on the default pool. Note that observers must unregister to stop the infinite loop.

Type Parameters:

T - the type of elements to produce

Parameters:

func - the function which generates elements

Returns:

the observable

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(@Nonnull
                                                        Func0<? extends T> func,
                                                        int count)

Creates an observable which repeatedly calls the given function count times to generate Ts and runs on the default pool.

Type Parameters:

T - the element type

Parameters:

func - the function to call to generate values

count - the numer of times to repeat the value

Returns:

the observable

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(@Nonnull
                                                        Func0<? extends T> func,
                                                        int count,
                                                        @Nonnull
                                                        Scheduler pool)

Creates an observable which repeatedly calls the given function count times to generate Ts and runs on the given pool.

Type Parameters:

T - the element type

Parameters:

func - the function to call to generate values

count - the numer of times to repeat the value

pool - the pool where the loop should be executed

Returns:

the observable

repeat

public static <T> ObservableBuilder<T> repeat(@Nonnull
                                              Func0<? extends T> func,
                                              @Nonnull
                                              Scheduler pool)

Creates an observable which repeatedly calls the given function which generates the Ts indefinitely. The generator runs on the pool. Note that observers must unregister to stop the infinite loop.

Type Parameters:

T - the type of elements to produce

Parameters:

func - the function which generates elements

pool - the pool where the generator loop runs

Returns:

the observable

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(T value)

Creates an observable which repeates the given value indefinitely and runs on the default pool. Note that the observers must deregister to stop the infinite background loop

Type Parameters:

T - the element type

Parameters:

value - the value to repeat

Returns:

the observable

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(T value,
                                                        int count)

Creates an observable which repeates the given value count times and runs on the default pool.

Type Parameters:

T - the element type

Parameters:

value - the value to repeat

count - the numer of times to repeat the value

Returns:

the observable

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(T value,
                                                        int count,
                                                        @Nonnull
                                                        Scheduler pool)

Creates an observable which repeates the given value count times and runs on the given pool.

Type Parameters:

T - the element type

Parameters:

value - the value to repeat

count - the numer of times to repeat the value

pool - the pool where the loop should be executed

Returns:

the observable

repeat

@Nonnull
public static <T> ObservableBuilder<T> repeat(T value,
                                                        @Nonnull
                                                        Scheduler pool)

Creates an observable which repeates the given value indefinitely and runs on the given pool. Note that the observers must deregister to stop the infinite background loop

Type Parameters:

T - the element type

Parameters:

value - the value to repeat

pool - the pool where the loop should be executed

Returns:

the observable

throwException

@Nonnull
public static <T> ObservableBuilder<T> throwException(@Nonnull
                                                                java.lang.Throwable ex)

Creates an observable which instantly sends the exception to its subscribers while running on the default pool.

Type Parameters:

T - the element type, irrelevant

Parameters:

ex - the exception to throw

Returns:

the new observable

throwException

@Nonnull
public static <T> ObservableBuilder<T> throwException(@Nonnull
                                                                java.lang.Throwable ex,
                                                                @Nonnull
                                                                Scheduler pool)

Creates an observable which instantly sends the exception to its subscribers while running on the given pool.

Type Parameters:

T - the element type, irrelevant

Parameters:

ex - the exception to throw

pool - the pool from where to send the values

Returns:

the new observable

tick

@Nonnull
public static ObservableBuilder<java.lang.Long> tick(long start,
                                                               long end,
                                                               long delay,
                                                               @Nonnull
                                                               java.util.concurrent.TimeUnit unit)

Returns an observable which produces an ordered sequence of numbers with the specified delay. It uses the default scheduler pool.

Parameters:

start - the starting value of the tick

end - the finishing value of the tick exclusive

delay - the delay value

unit - the time unit of the delay

Returns:

the observer

tick

@Nonnull
public static ObservableBuilder<java.lang.Long> tick(long start,
                                                               long end,
                                                               long delay,
                                                               @Nonnull
                                                               java.util.concurrent.TimeUnit unit,
                                                               @Nonnull
                                                               Scheduler pool)

Returns an observable which produces an ordered sequence of numbers with the specified delay.

Parameters:

start - the starting value of the tick inclusive

end - the finishing value of the tick exclusive

delay - the delay value

unit - the time unit of the delay

pool - the scheduler pool for the wait

Returns:

the observer

tick

@Nonnull
public static ObservableBuilder<java.lang.Long> tick(long delay,
                                                               @Nonnull
                                                               java.util.concurrent.TimeUnit unit)

Returns an observable which produces an ordered sequence of numbers with the specified delay. It uses the default scheduler pool.

Parameters:

delay - the delay value

unit - the time unit of the delay

Returns:

the observer

addTimeInterval

@Nonnull
public ObservableBuilder<TimeInterval<T>> addTimeInterval()

Returns an observable which provides a TimeInterval of Ts which records the elapsed time between successive elements. The time interval is evaluated using the System.nanoTime() differences as nanoseconds The first element contains the time elapsed since the registration occurred.

Returns:

the new observable

addTimestamped

@Nonnull
public ObservableBuilder<Timestamped<T>> addTimestamped()

Wrap the values within a observable to a timestamped value having always the System.currentTimeMillis() value.

Returns:

the raw observables of Ts

aggregate

@Nonnull
public ObservableBuilder<T> aggregate(@Nonnull
                                                Func2<? super T,? super T,? extends T> accumulator)

Apply an accumulator function over the observable source and submit the accumulated value to the returned observable.

Parameters:

accumulator - the accumulator function where the first parameter is the current accumulated value and the second is the now received value.

Returns:

the observable for the result of the accumulation

aggregate

@Nonnull
public <U,V> ObservableBuilder<V> aggregate(@Nonnull
                                                      Func2<? super U,? super T,? extends U> sum,
                                                      @Nonnull
                                                      Func2<? super U,? super java.lang.Integer,? extends V> divide)

Computes an aggregated value of the source Ts by applying a sum function and applying the divide function when the source finishes, sending the result to the output.

Type Parameters:

U - the type of the intermediate sum value

V - the type of the final average value

Parameters:

sum - the function which sums the input Ts. The first received T will be acompanied by a null U.

divide - the function which perform the final division based on the number of elements

Returns:

the observable for the average value

aggregate

@Nonnull
public <U> ObservableBuilder<U> aggregate(U seed,
                                                    @Nonnull
                                                    Func2<? super U,? super T,? extends U> accumulator)

Apply an accumulator function over the observable source and submit the accumulated value to the returned observable.

Type Parameters:

U - the ouput element type

Parameters:

seed - the initial value of the accumulator

accumulator - the accumulator function where the first parameter is the current accumulated value and the second is the now received value.

Returns:

the observable for the result of the accumulation

aggregate

@Nonnull
public <U,V> ObservableBuilder<V> aggregate(U seed,
                                                      @Nonnull
                                                      Func2<? super U,? super T,? extends U> accumulator,
                                                      @Nonnull
                                                      Func1<? super U,? extends V> resultSelector)

Aggregates the sequence via the accumulator function and transforms the result value with the selector.

Type Parameters:

U - the aggregation intermediate type

V - the result type

Parameters:

seed - the initial value for the aggregation

accumulator - the accumulation function

resultSelector - the result selector

Returns:

the new observable

Since:

0.97

aggregate

@Nonnull
public <U,V> ObservableBuilder<V> aggregate(U seed,
                                                      @Nonnull
                                                      Func2<? super U,? super T,? extends U> accumulator,
                                                      @Nonnull
                                                      Func2<? super U,? super java.lang.Integer,? extends V> divider)

Computes an aggregated value of the source Ts by using the initial seed, applying an accumulator function and applying the divide function when the source finishes, sending the result to the output.

Type Parameters:

U - the type of the intermediate sum value

V - the type of the final average value

Parameters:

seed - the initieal value for the aggregation

accumulator - the function which sums the input Ts. The first received T will be accompanied by a null U.

divider - the function which perform the final division based on the number of elements

Returns:

the observable for the average value

Since:

0.97

all

@Nonnull
public ObservableBuilder<java.lang.Boolean> all(@Nonnull
                                                          Func1<? super T,java.lang.Boolean> predicate)

Signals a single true or false if all elements of the observable matches the predicate. It may return early with a result of false if the predicate simply does not match the current element. For a true result, it waits for all elements of the source observable.

Parameters:

predicate - the predicate to setisfy

Returns:

the observable resulting in a single result

amb

@Nonnull
public ObservableBuilder<T> amb(@Nonnull
                                          java.lang.Iterable<? extends Observable<? extends T>> others)

Channels the values of the first observable who fires first from the given set of observables. E.g., O3 = Amb(O1, O2) if O1 starts to submit events first, O3 will relay these events and events of O2 will be completely ignored

Parameters:

others - the iterable sequence of the other observables

Returns:

the observable channeling the first reacting values

amb

@Nonnull
public ObservableBuilder<T> amb(@Nonnull
                                          Observable<? extends T> other)

Channels the values from the first observable (this or other) who fires firts.

Parameters:

other - the other observable

Returns:

the observable channeling the first reacting observable

any

@Nonnull
public ObservableBuilder<java.lang.Boolean> any()

Signals a single true if the source observable contains any element. It might return early for a non-empty source but waits for the entire observable to return false.

Returns:

the observable

any

@Nonnull
public ObservableBuilder<java.lang.Boolean> any(@Nonnull
                                                          Func1<? super T,java.lang.Boolean> predicate)

Signals a single TRUE if the source signals any next() and the value matches the predicate before it signals a finish(). It signals a false otherwise.

Parameters:

predicate - the predicate to test the values

Returns:

the observable.

averageBigDecimal

@Nonnull
public ObservableBuilder<java.math.BigDecimal> averageBigDecimal()

Computes and signals the average value of the BigDecimal source. The source may not send nulls.

Note that it uses forced cast of this sequence. If T != BigDecimal the observations might throw a ClassCastException.

Returns:

the observable for the average value

averageBigInteger

@Nonnull
public ObservableBuilder<java.math.BigDecimal> averageBigInteger()

Computes and signals the average value of the BigInteger source. The source may not send nulls.

Note that it uses forced cast of this sequence. If T != BigInteger the observations might throw a ClassCastException.

Returns:

the observable for the average value

averageDouble

@Nonnull
public ObservableBuilder<java.lang.Double> averageDouble()

Computes and signals the average value of the Double source. The source may not send nulls.

Note that it uses forced cast of this sequence. If T != Double the observations might throw a ClassCastException.

Returns:

the observable for the average value

averageFloat

@Nonnull
public ObservableBuilder<java.lang.Float> averageFloat()

Computes and signals the average value of the Float source. The source may not send nulls.

Note that it uses forced cast of this sequence. If T != Float the observations might throw a ClassCastException.

Returns:

the observable for the average value

averageInt

@Nonnull
public ObservableBuilder<java.lang.Double> averageInt()

Computes and signals the average value of the integer source. The source may not send nulls. The intermediate aggregation used double values.

Note that it uses forced cast of this sequence. If T != Integer the observations might throw a ClassCastException.

Returns:

the observable for the average value

averageLong

@Nonnull
public ObservableBuilder<java.lang.Double> averageLong()

Computes and signals the average value of the Long source. The source may not send nulls. The intermediate aggregation used double values.

Note that it uses forced cast of this sequence. If T != Long the observations might throw a ClassCastException.

Returns:

the observable for the average value

await

public T await()

Waits indefinitely for the observable to complete and returns the last value. If the source terminated with an error, the exception is rethrown, wrapped into RuntimeException if necessary. If the source didn't produce any elements or is interrupted, a NoSuchElementException is thrown.

Returns:

the last value of the sequence in case the observable terminated with finish.

Since:

0.97

See Also:

last()

await

public T await(long time,
               @Nonnull
               java.util.concurrent.TimeUnit unit)

Waits a limited amount of time for the observable to complete and returns the last value. If the source terminated with an error, the exception is rethrown, wrapped into RuntimeException if necessary. If the source didn't produce any elements, times out or is interrupted, a NoSuchElementException is thrown.

The difference from the last operator is that unlike last, this operator does not treat the error event as just a termination signal.

Parameters:

time - the wait time

unit - the wait time unit

Returns:

the last value of the sequence

Since:

0.97

See Also:

last()

buffer

@Nonnull
public <U> ObservableBuilder<java.util.List<T>> buffer(@Nonnull
                                                                 Func0<Observable<U>> windowClosingSelector)

Buffer parts of the source until the window observable finishes.

Type Parameters:

U - the window's own type (ignored)

Parameters:

windowClosingSelector - the window selector

Returns:

the observable for the buffered items

Since:

0.97

buffer

@Nonnull
public ObservableBuilder<java.util.List<T>> buffer(int bufferSize)

Buffer the nodes as they become available and send them out in bufferSize chunks. The observers return a new and modifiable list of T on every next() call.

Parameters:

bufferSize - the target buffer size

Returns:

the observable of the list

buffer

@Nonnull
public ObservableBuilder<java.util.List<T>> buffer(int bufferSize,
                                                             int skip)

Buffer the nodes as they become available and send them out in bufferSize chunks. The observers return a new and modifiable list of T on every next() call.

Parameters:

bufferSize - the target buffer size

skip - the number of elements to skip between buffers.

Returns:

the observable of the list

Since:

0.97

buffer

@Nonnull
public ObservableBuilder<java.util.List<T>> buffer(int bufferSize,
                                                             long time,
                                                             @Nonnull
                                                             java.util.concurrent.TimeUnit unit)

Buffer the Ts of the source until the buffer reaches its capacity or the current time unit runs out. Might result in empty list of Ts and might complete early when the source finishes before the time runs out. It uses the default scheduler pool.

Parameters:

bufferSize - the allowed buffer size

time - the time value to wait betveen buffer fills

unit - the time unit

Returns:

the observable of list of Ts

buffer

@Nonnull
public ObservableBuilder<java.util.List<T>> buffer(int bufferSize,
                                                             long time,
                                                             @Nonnull
                                                             java.util.concurrent.TimeUnit unit,
                                                             @Nonnull
                                                             Scheduler pool)

Buffer the Ts of the source until the buffer reaches its capacity or the current time unit runs out. Might result in empty list of Ts and might complete early when the source finishes before the time runs out.

Parameters:

bufferSize - the allowed buffer size

time - the time value to wait betveen buffer fills

unit - the time unit

pool - the pool where to schedule the buffer splits

Returns:

the observable of list of Ts

buffer

@Nonnull
public ObservableBuilder<java.util.List<T>> buffer(long time,
                                                             @Nonnull
                                                             java.util.concurrent.TimeUnit unit)

Buffers the source observable Ts into a list of Ts periodically and submits them to the returned observable. Each next() invocation contains a new and modifiable list of Ts. The signaled List of Ts might be empty if no Ts appeared from the original source within the current timespan. The last T of the original source triggers an early submission to the output. The scheduling is done on the default Scheduler.

Parameters:

time - the time value to split the buffer contents.

unit - the time unit of the time

Returns:

the observable of list of Ts

buffer

@Nonnull
public ObservableBuilder<java.util.List<T>> buffer(long time,
                                                             @Nonnull
                                                             java.util.concurrent.TimeUnit unit,
                                                             @Nonnull
                                                             Scheduler pool)

Buffers the source observable Ts into a list of Ts periodically and submits them to the returned observable. Each next() invocation contains a new and modifiable list of Ts. The signaled List of Ts might be empty if no Ts appeared from the original source within the current timespan. The last T of the original source triggers an early submission to the output.

Parameters:

time - the time value to split the buffer contents.

unit - the time unit of the time

pool - the scheduled execution pool to use

Returns:

the observable of list of Ts

buffer

@Nonnull
public <U,V> ObservableBuilder<java.util.List<T>> buffer(@Nonnull
                                                                   Observable<? extends U> windowOpening,
                                                                   @Nonnull
                                                                   Func1<? super U,? extends Observable<V>> windowClosing)

Projects the incoming values into multiple buffers based on when a window-open fires an event and a window-close finishes. An incoming value might end up in multiple buffers if their window overlaps.

Exception semantics: if any Observable throws an error, the whole process terminates with error.

Type Parameters:

U - the buffer opening selector type

V - the buffer closing element type (irrelevant)

Parameters:

windowOpening - the window-open observable

windowClosing - the function that returns a window-close observable for a value from the window-open

Returns:

the observable for the buffered items

Since:

0.97

buffer

@Nonnull
public <U> ObservableBuilder<java.util.List<T>> buffer(@Nonnull
                                                                 Observable<U> boundary)

Buffers the source elements into non-overlapping lists separated by notification values from the boundary observable and its finish event.

Exception semantics: if any Observable throws an error, the whole process terminates with error.

Type Parameters:

U - the window's own type (ignored)

Parameters:

boundary - the notification source of the boundary

Returns:

the observable for the buffered items

Since:

0.97

cast

@Nonnull
public <U> ObservableBuilder<U> cast()

Casts the values of this observable implicitly and forwards a ClassCastException if it occurs.

Type Parameters:

U - the output type

Returns:

the observable containing Ts

Since:

0.97

cast

@Nonnull
public <U> ObservableBuilder<U> cast(@Nonnull
                                               java.lang.Class<U> token)

Casts the values of this observable via the given type token or forwards a ClassCastException.

Type Parameters:

U - the output type

Parameters:

token - the token to test agains the elements

Returns:

the observable containing Ts

Since:

0.97

chunkify

@Nonnull
public java.lang.Iterable<java.util.List<T>> chunkify()

Produces an iterable sequence of consequtive (possibly empty) chunks of the source sequence.

Returns:

the chunks

Since:

0.97

See Also:

Reactive.chunkify(Observable)

collect

@Nonnull
public <U> java.lang.Iterable<U> collect(@Nonnull
                                                   Func0<? extends U> newCollector,
                                                   @Nonnull
                                                   Func2<? super U,? super T,? extends U> merge)

Produces an enumerable sequence that returns elements collected/aggregated/whatever from the source between consequtive iterations.

Type Parameters:

U - the result type

Parameters:

newCollector - the factory method for the current collector

merge - the merger that combines elements

Returns:

the new iterable

Since:

0.97

See Also:

Reactive.collect(Observable, Func0, Func2)

collect

@Nonnull
public <U> CloseableIterable<U> collect(@Nonnull
                                                  Func0<? extends U> initialCollector,
                                                  @Nonnull
                                                  Func2<? super U,? super T,? extends U> merge,
                                                  @Nonnull
                                                  Func1<? super U,? extends U> newCollector)

Produces an iterable sequence that returns elements collected/aggregated/whatever from the source sequence between consequtive iteration.

Type Parameters:

U - the result element type

Parameters:

initialCollector - the initial collector factory

merge - the merger operator

newCollector - the factory to replace the current collector

Returns:

the sequence

Since:

0.97

See Also:

Reactive.collect(Observable, Func0, Func2, Func1)

combineFirst

@Nonnull
public ObservableBuilder<java.util.List<T>> combineFirst(@Nonnull
                                                                   java.util.List<? extends Observable<? extends T>> srcs)

Combine the incoming Ts of the various observables into a single list of Ts like using Reactive.zip() on more than two sources.

Parameters:

srcs - the iterable of observable sources.

Returns:

the new observable

combineLatest

@Nonnull
public <U,V> ObservableBuilder<V> combineLatest(@Nonnull
                                                          Observable<? extends U> right,
                                                          @Nonnull
                                                          Func2<? super T,? super U,? extends V> selector)

Returns an observable which combines the latest values of both streams whenever one sends a new value, but only after both sent a value.

Exception semantics: if any stream throws an exception, the output stream throws an exception and all subscriptions are terminated.

Completion semantics: The output stream terminates after both streams terminate.

The function will start combining the values only when both sides have already sent a value.

Type Parameters:

U - the right element type

V - the result element type

Parameters:

right - the right stream

selector - the function which combines values from both streams and returns a new value

Returns:

the new observable.

combineLatest0

@Nonnull
public <U,V> ObservableBuilder<V> combineLatest0(@Nonnull
                                                           Observable<? extends U> right,
                                                           @Nonnull
                                                           Func2<? super T,? super U,? extends V> selector)

Returns an observable which combines the latest values of both streams whenever one sends a new value.

Exception semantics: if any stream throws an exception, the output stream throws an exception and all subscriptions are terminated.

Completion semantics: The output stream terminates after both streams terminate.

Note that at the beginning, when the left or right fires first, the selector function will receive (value, null) or (null, value). If you want to react only in cases when both have sent a value, use the #combineLatest(Observable, Observable, Func2) method.

Type Parameters:

U - the right element type

V - the result element type

Parameters:

right - the right stream

selector - the function which combines values from both streams and returns a new value

Returns:

the new observable.

concat

@Nonnull
public ObservableBuilder<T> concat(@Nonnull
                                             java.lang.Iterable<? extends Observable<? extends T>> sources)

Concatenates the source observables in a way that when the first finish(), the second gets registered and continued, and so on.

Parameters:

sources - the source list of subsequent observables

Returns:

the concatenated observable

concat

@Nonnull
public ObservableBuilder<T> concat(@Nonnull
                                             Observable<? extends T> second)

Concatenate two observables in a way when the first finish() the second is registered and continued with.

Parameters:

second - the second observable

Returns:

the concatenated observable

concatAll

@Nonnull
public ObservableBuilder<T> concatAll(@Nonnull
                                                Observable<? extends Observable<? extends T>> sources)

Concatenate the the multiple sources of T one after another.

Exception semantics: if the sources or any inner observer signals an error, the outer observable will signal that error and the sequence is terminated.

Parameters:

sources - the observable sequence of the observable sequence of Ts.

Returns:

the new observable

connect

@Nonnull
public java.io.Closeable connect()

Connect this observable if the underlying observable supports the ConnectableObservable interface, or throw an UnsupportedOperationException.

Returns:

the connection handle

contains

@Nonnull
public ObservableBuilder<java.lang.Boolean> contains(@Nonnull
                                                               Func0<? extends T> supplier)

Signals a single TRUE if the source observable signals a value equals() with the supplied value. Both the source and the test value might be null. The signal goes after the first encounter of the given value.

Parameters:

supplier - the supplier for the comparison value

Returns:

the observer for contains

Since:

0.97

contains

@Nonnull
public ObservableBuilder<java.lang.Boolean> contains(T value)

Signals a single TRUE if the source observable signals a value equals() with the source value. Both the source and the test value might be null. The signal goes after the first encounter of the given value.

Parameters:

value - the value to look for

Returns:

the observer for contains

count

@Nonnull
public ObservableBuilder<java.lang.Integer> count()

Counts the number of elements in the observable source.

Returns:

the count signal

count

@Nonnull
public ObservableBuilder<java.lang.Integer> count(@Nonnull
                                                            Func1<? super T,java.lang.Boolean> predicate)

Counts the number of elements where the predicate returns true.

Parameters:

predicate - the predicate function

Returns:

the count signal

Since:

0.97

countLong

@Nonnull
public ObservableBuilder<java.lang.Long> countLong()

Counts the number of elements in the observable source as a long.

Returns:

the count signal

countLong

@Nonnull
public ObservableBuilder<java.lang.Integer> countLong(@Nonnull
                                                                Func1<? super T,java.lang.Boolean> predicate)

Counts the number of elements where the predicate returns true as long.

Parameters:

predicate - the predicate function

Returns:

the count signal

Since:

0.97

debugState

@Nonnull
public ObservableBuilder<T> debugState()

Constructs an observer which logs errors in case next(), finish() or error() is called and the observer is not in running state anymore due an earlier finish() or error() call.

Returns:

the augmented observable

defaultIfEmpty

@Nonnull
public ObservableBuilder<T> defaultIfEmpty(Func0<? extends T> defaultValueFunc)

Returns the default value provided by the function if the source sequence is empty.

Parameters:

defaultValueFunc - the default value factory

Returns:

the new observable

Since:

0.97

defaultIfEmpty

@Nonnull
public ObservableBuilder<T> defaultIfEmpty(T defaultValue)

Returns the default value if the source sequence is empty.

Parameters:

defaultValue - the default value

Returns:

the new observable

Since:

0.97

delay

@Nonnull
public <U> ObservableBuilder<T> delay(@Nonnull
                                                Func1<? super T,? extends Observable<U>> delaySelector)

Delays (ties) the event delivery of the source, for each source value T, to the firing of the observable returned by the delay selector.

Exception semantics: Exceptions appearing through any observable will terminate the sequence immediately.

Type Parameters:

U - the element type of the value delivery observables, irrelevant

Parameters:

delaySelector - for each source value T, it returns an observable whose next or finish events will deliver the original value T.

Returns:

the delayed observable.

Since:

0.97

delay

@Nonnull
public ObservableBuilder<T> delay(long time,
                                            @Nonnull
                                            java.util.concurrent.TimeUnit unit)

Delays the propagation of events of the source by the given amount. It uses the pool for the scheduled waits. The delay preserves the relative time difference between subsequent notifiactions. It uses the default scheduler pool when submitting the delayed values

Parameters:

time - the time value

unit - the time unit

Returns:

the delayed observable of Ts

delay

@Nonnull
public ObservableBuilder<T> delay(long time,
                                            @Nonnull
                                            java.util.concurrent.TimeUnit unit,
                                            @Nonnull
                                            Scheduler pool)

Delays the propagation of events of the source by the given amount. It uses the pool for the scheduled waits. The delay preserves the relative time difference between subsequent notifiactions

Parameters:

time - the time value

unit - the time unit

pool - the pool to use for scheduling

Returns:

the delayed observable of Ts

delay

@Nonnull
public <U,V> ObservableBuilder<T> delay(@Nonnull
                                                  Observable<U> registerDelay,
                                                  @Nonnull
                                                  Func1<? super T,? extends Observable<V>> delaySelector)

Delays (ties) the event delivery of the source to the firing of registerDelay (optionally) and for each source value T, to the firing of the observable returned by the delay selector.

Exception semantics: Exceptions appearing through any observable will terminate the sequence immediately.

Type Parameters:

U - the element type of the registration delaying observable, irrelevant

V - the element type of the value delivery observables, irrelevant

Parameters:

registerDelay - if not null, the actual registration to the source is delayed by the first next or finish event from this observable.

delaySelector - for each source value T, it returns an observable whose next or finish events will deliver the original value T.

Returns:

the delayed observable.

Since:

0.97

delayRegister

@Nonnull
public ObservableBuilder<T> delayRegister(long time,
                                                    @Nonnull
                                                    java.util.concurrent.TimeUnit unit)

Delays the registration to the underlying observable by a given amount. Uses the default scheduler.

Parameters:

time - the time to wait

unit - the time unit

Returns:

the observable with the delayed register

Since:

0.97

delayRegister

@Nonnull
public ObservableBuilder<T> delayRegister(long time,
                                                    @Nonnull
                                                    java.util.concurrent.TimeUnit unit,
                                                    @Nonnull
                                                    Scheduler pool)

Delays the registration to the underlying observable by a given amount.

Parameters:

time - the time to wait

unit - the time unit

pool - the scheduler pool where to wait.

Returns:

the observable with the delayed register

Since:

0.97

dematerialize

@Nonnull
public ObservableBuilder<T> dematerialize()

Returns an observable which converts all option messages back to regular next(), error() and finish() messages. The returned observable adheres to the next* (error|finish)? pattern, which ensures that no further options are relayed after an error or finish.

Returns:

the new observable

See Also:

#materialize(Observable)

distinct

@Nonnull
public ObservableBuilder<T> distinct()

Returns the distinct elements from the source.

Returns:

the new observable

distinct

@Nonnull
public <U> ObservableBuilder<T> distinct(@Nonnull
                                                   Func1<? super T,? extends U> keyExtractor,
                                                   Func2<? super U,? super U,java.lang.Boolean> keyComparer)

Returns a sequence of elements who are distinct in terms of the given key extracted by a function and compared against each other via the comparer function.

Type Parameters:

U - the key type

Parameters:

keyExtractor - the key extractor function

keyComparer - the key comparer function.

Returns:

the new observer

Since:

0.97

distinct

@Nonnull
public <U> ObservableBuilder<T> distinct(@Nonnull
                                                   Func1<T,U> keyExtractor)

Returns a sequence of elements distinct in terms of the key extracted from them.

Type Parameters:

U - the key type

Parameters:

keyExtractor - the key extractor

Returns:

the new observer

distinct

@Nonnull
public ObservableBuilder<T> distinct(Func2<? super T,? super T,java.lang.Boolean> comparer)

Returns the distinct elements from the source according to the given comparator function.

Parameters:

comparer - the element comparer

Returns:

the new observable

Since:

0.97

doWhile

@Nonnull
public ObservableBuilder<T> doWhile(@Nonnull
                                              Func0<java.lang.Boolean> condition)

Repeats the given source so long as the condition returns true. The condition is checked after each completion of the source sequence.

Exception semantics: exception received will stop the repeat process and is delivered to observers as-is.

Parameters:

condition - the condition to check

Returns:

the new observable

Since:

0.97

drain

@Nonnull
public ObservableBuilder<java.lang.Void> drain(@Nonnull
                                                         Func1<? super T,? extends Observable<java.lang.Void>> pump)

Maintains a queue of Ts which is then drained by the pump. Uses the default pool.

Parameters:

pump - the pump that drains the queue

Returns:

the new observable

drain

@Nonnull
public ObservableBuilder<java.lang.Void> drain(@Nonnull
                                                         Func1<? super T,? extends Observable<java.lang.Void>> pump,
                                                         @Nonnull
                                                         Scheduler pool)

Maintains a queue of Ts which is then drained by the pump.

Parameters:

pump - the pump that drains the queue

pool - the pool for the drain

Returns:

the new observable

elementAt

@Nonnull
public ObservableBuilder<T> elementAt(int index)

Returns a single element from the sequence at the index or throws a NoSuchElementException if the sequence terminates before this index.

Exception semantics: errors from source are propagated as-is.

Parameters:

index - the index to look at

Returns:

the observable which returns the element at index or an exception

Since:

0.97

elementAt

@Nonnull
public ObservableBuilder<T> elementAt(int index,
                                                @Nonnull
                                                Func0<? extends T> defaultSupplier)

Returns a single element from the sequence at the index or the default value supplied if the sequence terminates before this index.

Exception semantics: errors from source are propagated as-is.

Parameters:

index - the index to look at

defaultSupplier - the function that will supply the default value

Returns:

the observable which returns the element at index or the default value supplied

Since:

0.97

elementAt

@Nonnull
public ObservableBuilder<T> elementAt(int index,
                                                T defaultValue)

Returns a single element from the sequence at the index or the default value if the sequence terminates before this index.

Exception semantics: errors from source are propagated as-is.

Parameters:

index - the index to look at

defaultValue - the value to return if the sequence is sorter than index

Returns:

the observable which returns the element at index or the default value

Since:

0.97

empty

@Nonnull
public ObservableBuilder<T> empty()

Returns an empty observable, which fires only finish().

Returns:

Returns an empty observable which signals only finish() on the default observer pool.

empty

@Nonnull
public ObservableBuilder<T> empty(@Nonnull
                                            Scheduler pool)

Returns an empty observable which signals only finish() on the given pool.

Parameters:

pool - the pool to invoke the the finish()

Returns:

the observable

finish

@Nonnull
public ObservableBuilder<T> finish(@Nonnull
                                             Action0 action)

Invokes the given action when the source signals a finish() or error().

Parameters:

action - the action to invoke on finish() or error()

Returns:

the new observable

first

public T first()

Blocks until the first element of the observable becomes available and returns that element. Might block forever. Might throw a NoSuchElementException when the observable doesn't produce any more elements.

Returns:

the first element

first

public T first(@Nonnull
               Func0<? extends T> defaultSupplier)

Blocks until the first element of the observable becomes available and returns that element or returns the supplier's value if the observable is empty. Might block forever.

Parameters:

defaultSupplier - the supplier of default value in case the source is empty

Returns:

the first element or the supplier's value

Since:

0.97

first

public T first(T defaultValue)

Blocks until the first element of the observable becomes available and returns that element or returns the default value if the observable is empty. Might block forever.

Parameters:

defaultValue - the default value in case the observable is empty

Returns:

the first element or the default value

Since:

0.97

firstAsync

@Nonnull
public ObservableBuilder<T> firstAsync()

Returns an observable which takes the first value from the source observable as a single element or throws NoSuchElementException if the source is empty.

Exception semantics: errors from source are propagated as-is.

Returns:

the new observable

Since:

0.97

firstAsync

@Nonnull
public ObservableBuilder<T> firstAsync(@Nonnull
                                                 Func0<? extends T> defaultSupplier)

Returns an observable which takes the first value from the source observable as a single element or the supplier's value if the source is empty.

Exception semantics: errors from source are propagated as-is.

Parameters:

defaultSupplier - the default value supplier

Returns:

the new observable

Since:

0.97

firstAsync

@Nonnull
public ObservableBuilder<T> firstAsync(T defaultValue)

Returns an observable which takes the first value from the source observable as a single element or the default value if the source is empty.

Exception semantics: errors from source are propagated as-is.

Parameters:

defaultValue - the default value to return

Returns:

the new observable

Since:

0.97

forEach

public void forEach(@Nonnull
                    Action1<? super T> action)
             throws java.lang.InterruptedException

Invokes the action on each element in the source, and blocks until the source terminates either way.

The observation of the source is not serialized, therefore, action might be invoked concurrently by subsequent source elements.

Parameters:

action - the action to invoke on each element.

Throws:

java.lang.InterruptedException - if the wait is interrupted

forEach

public boolean forEach(@Nonnull
                       Action1<? super T> action,
                       long time,
                       @Nonnull
                       java.util.concurrent.TimeUnit unit)
                throws java.lang.InterruptedException

Invokes the action on each element in the source, and blocks until the source terminates or the time runs out.

The observation of the source is not serialized, therefore, action might be invoked concurrently by subsequent source elements.

Parameters:

action - the action to invoke on each element.

time - the waiting time

unit - the waiting time unit

Returns:

false if a timeout occurred instead of normal termination

Throws:

java.lang.InterruptedException - if the wait is interrupted

Since:

0.97

forEach

public void forEach(@Nonnull
                    Action2<? super T,? super java.lang.Integer> action)
             throws java.lang.InterruptedException

Invokes the indexed action on each element in the source, and blocks until the source terminates either way.

The observation of the source is not serialized, therefore, action might be invoked concurrently by subsequent source elements.

Parameters:

action - the action to invoke on each element.

Throws:

java.lang.InterruptedException - if the wait is interrupted

forEach

public boolean forEach(@Nonnull
                       Action2<? super T,? super java.lang.Integer> action,
                       long time,
                       @Nonnull
                       java.util.concurrent.TimeUnit unit)
                throws java.lang.InterruptedException

Invokes the indexed action on each element in the source, and blocks until the source terminates either way.

The observation of the source is not serialized, therefore, action might be invoked concurrently by subsequent source elements.

Parameters:

action - the action to invoke on each element.

time - the waiting time

unit - the waiting time unit

Returns:

false if a timeout occurred instead of normal termination

Throws:

java.lang.InterruptedException - if the wait is interrupted

Since:

0.97

forkJoin

@Nonnull
public ObservableBuilder<java.util.List<T>> forkJoin(@Nonnull
                                                               java.lang.Iterable<? extends Observable<? extends T>> sources)

Runs the observables in parallel and joins their last values whenever one fires.

Parameters:

sources - the list of sources

Returns:

the observable

groupBy

@Nonnull
public <Key> ObservableBuilder<GroupedObservable<Key,T>> groupBy(@Nonnull
                                                                           Func1<? super T,? extends Key> keyExtractor)

Group the specified source accoring to the keys provided by the extractor function. The resulting observable gets notified once a new group is encountered. Each previously encountered group by itself receives updates along the way. If the source finish(), all encountered group will finish().

Type Parameters:

Key - the key type of the group

Parameters:

keyExtractor - the key extractor which creates Keys from Ts

Returns:

the observable

groupBy

@Nonnull
public <U,Key> ObservableBuilder<GroupedObservable<Key,U>> groupBy(@Nonnull
                                                                             Func1<? super T,? extends Key> keyExtractor,
                                                                             @Nonnull
                                                                             Func1<? super T,? extends U> valueExtractor)

Group the specified source according to the keys provided by the extractor function. The resulting observable gets notified once a new group is encountered. Each previously encountered group by itself receives updates along the way. If the source finish(), all encountered group will finish().

Type Parameters:

U - the type of the output element

Key - the key type of the group

Parameters:

keyExtractor - the key extractor which creates Keys from Ts

valueExtractor - the extractor which makes Us from Ts

Returns:

the observable

groupByUntil

@Nonnull
public <K,D> ObservableBuilder<GroupedObservable<K,T>> groupByUntil(@Nonnull
                                                                              Func1<? super T,? extends K> keySelector,
                                                                              @Nonnull
                                                                              Func1<? super GroupedObservable<K,T>,? extends Observable<D>> durationSelector)

Groups the source sequence of Ts until the specified duration for that group fires.

The key comparison is done by the Object.equals() semantics of the HashMap.

Exception semantics: if the source throws an exception, all active groups will receive the exception followed by the outer observer of the groups.

Completion semantics: if the source finishes, all active groups will receive a finish signal followed by the outer observer.

Type Parameters:

K - the key type

D - the duration element type, ignored

Parameters:

keySelector - the key extractor

durationSelector - the observable for a particular group termination

Returns:

the new observable

groupByUntil

@Nonnull
public <K,D> ObservableBuilder<GroupedObservable<K,T>> groupByUntil(@Nonnull
                                                                              Func1<? super T,? extends K> keySelector,
                                                                              @Nonnull
                                                                              Func1<? super GroupedObservable<K,T>,? extends Observable<D>> durationSelector,
                                                                              @Nonnull
                                                                              Func2<? super K,? super K,java.lang.Boolean> keyComparer)

Groups the source sequence of Ts until the specified duration for that group fires.

Exception semantics: if the source throws an exception, all active groups will receive the exception followed by the outer observer of the groups.

Completion semantics: if the source finishes, all active groups will receive a finish signal followed by the outer observer.

Type Parameters:

K - the key type

D - the duration element type, ignored

Parameters:

keySelector - the key extractor

durationSelector - the observable for a particular group termination

keyComparer - the key comparer for the grouping

Returns:

the new observable

groupByUntil

@Nonnull
public <K,V,D> ObservableBuilder<GroupedObservable<K,V>> groupByUntil(@Nonnull
                                                                                Func1<? super T,? extends K> keySelector,
                                                                                @Nonnull
                                                                                Func1<? super T,? extends V> valueSelector,
                                                                                @Nonnull
                                                                                Func1<? super GroupedObservable<K,V>,? extends Observable<D>> durationSelector)

Groups the source sequence of Ts until the specified duration for that group fires.

The key comparison is done by the Object.equals() semantics of the HashMap.

Exception semantics: if the source throws an exception, all active groups will receive the exception followed by the outer observer of the groups.

Completion semantics: if the source finishes, all active groups will receive a finish signal followed by the outer observer.

Type Parameters:

K - the key type

V - the value type

D - the duration element type, ignored

Parameters:

keySelector - the key extractor

valueSelector - the value extractor

durationSelector - the observable for a particular group termination

Returns:

the new observable

groupByUntil

@Nonnull
public <K,V,D> ObservableBuilder<GroupedObservable<K,V>> groupByUntil(@Nonnull
                                                                                Func1<? super T,? extends K> keySelector,
                                                                                @Nonnull
                                                                                Func1<? super T,? extends V> valueSelector,
                                                                                @Nonnull
                                                                                Func1<? super GroupedObservable<K,V>,? extends Observable<D>> durationSelector,
                                                                                @Nonnull
                                                                                Func2<? super K,? super K,java.lang.Boolean> keyComparer)

Groups the source sequence of Ts until the specified duration for that group fires.

Exception semantics: if the source throws an exception, all active groups will receive the exception followed by the outer observer of the groups.

Completion semantics: if the source finishes, all active groups will receive a finish signal followed by the outer observer.

Type Parameters:

K - the key type

V - the value type

D - the duration element type, ignored

Parameters:

keySelector - the key extractor

valueSelector - the value extractor

durationSelector - the observable for a particular group termination

keyComparer - the key comparer for the grouping

Returns:

the new observable

groupJoin

@Nonnull
public <Right,LeftDuration,RightDuration,Result> ObservableBuilder<Result> groupJoin(@Nonnull
                                                                                               Observable<? extends Right> right,
                                                                                               @Nonnull
                                                                                               Func1<? super T,? extends Observable<LeftDuration>> leftDurationSelector,
                                                                                               @Nonnull
                                                                                               Func1<? super Right,? extends Observable<RightDuration>> rightDurationSelector,
                                                                                               @Nonnull
                                                                                               Func2<? super T,? super Observable<? extends Right>,? extends Result> resultSelector)

Returns an observable which correlates two streams of values based on their time when they overlapped and groups the results.

Type Parameters:

Right - the element type of the right stream

LeftDuration - the overlapping duration indicator for the left stream (e.g., the event when it leaves)

RightDuration - the overlapping duration indicator for the right stream (e.g., the event when it leaves)

Result - the type of the grouping based on the coincidence.

Parameters:

right - the right source of elements

leftDurationSelector - the duration selector for a left element

rightDurationSelector - the duration selector for a right element

resultSelector - the selector which will produce the output value

Returns:

the new observable

See Also:

#join(Observable, Observable, Func1, Func1, Func2)

ignoreValues

@Nonnull
public ObservableBuilder<T> ignoreValues()

Ignores the next() messages of the source and forwards only the error() and finish() messages.

Returns:

the new observable

into

@Nonnull
public <U extends java.util.Collection<? super T>> U into(@Nonnull
                                                                    U out)

Add the elements of the sequence into the supplied collection.

Type Parameters:

U - a collection type

Parameters:

out - the output collection

Returns:

the same out value

Since:

0.97

invoke

@Nonnull
public ObservableBuilder<T> invoke(@Nonnull
                                             Action1<? super T> action)

Invoke a specific action before relaying the Ts to the observable. The action might have some effect on each individual Ts passing through this filter.

Parameters:

action - the action to invoke on every T

Returns:

the new observable

invoke

@Nonnull
public ObservableBuilder<T> invoke(@Nonnull
                                             Action1<? super T> onNext,
                                             @Nonnull
                                             Action0 onFinish)

Invokes the given actions while relaying events.

Parameters:

onNext - the action for next

onFinish - the action for finish

Returns:

the augmented observable

Since:

0.97

invoke

@Nonnull
public ObservableBuilder<T> invoke(@Nonnull
                                             Action1<? super T> onNext,
                                             @Nonnull
                                             Action1<? super java.lang.Throwable> onError)

Invokes the given actions while relaying events.

Parameters:

onNext - the action for next

onError - the action for error

Returns:

the augmented observable

Since:

0.97

invoke

@Nonnull
public ObservableBuilder<T> invoke(@Nonnull
                                             Action1<? super T> onNext,
                                             @Nonnull
                                             Action1<? super java.lang.Throwable> onError,
                                             @Nonnull
                                             Action0 onFinish)

Invokes the given actions while relaying events.

Parameters:

onNext - the action for next

onError - the action for error

onFinish - the action for finish

Returns:

the augmented observable

Since:

0.97

invoke

@Nonnull
public ObservableBuilder<T> invoke(@Nonnull
                                             Observer<? super T> observer)

Invoke a specific observer before relaying the Ts, finish() and error() to the observable. The action might have some effect on each individual Ts passing through this filter.

Parameters:

observer - the observer to invoke before any registered observers are called

Returns:

the new observable

isEmpty

@Nonnull
public ObservableBuilder<java.lang.Boolean> isEmpty()

Signals true if the source observable fires finish() without ever firing next(). This means once the next() is fired, the resulting observer will return early.

Returns:

the observer

isInstance

public boolean isInstance(@Nonnull
                          java.lang.Class<?> clazz)

Checks if the wrapped Observable is the instance of the given class or interface according to Class.isInstance().

Parameters:

clazz - the class to check against

Returns:

true if the wrapped Observable is assignable to such type

Since:

0.97

join

@Nonnull
public <Right,LeftDuration,RightDuration,Result> ObservableBuilder<Result> join(@Nonnull
                                                                                          Observable<? extends Right> right,
                                                                                          @Nonnull
                                                                                          Func1<? super T,? extends Observable<LeftDuration>> leftDurationSelector,
                                                                                          @Nonnull
                                                                                          Func1<? super Right,? extends Observable<RightDuration>> rightDurationSelector,
                                                                                          @Nonnull
                                                                                          Func2<? super T,? super Right,? extends Result> resultSelector)

Returns an observable which correlates two streams of values based on their time when they overlapped.

The difference between this operator and the groupJoin operator is that in this case, the result selector takes the concrete left and right elements, whereas the groupJoin associates an observable of rights for each left.

Type Parameters:

Right - the element type of the right stream

LeftDuration - the overlapping duration indicator for the left stream (e.g., the event when it leaves)

RightDuration - the overlapping duration indicator for the right stream (e.g., the event when it leaves)

Result - the type of the grouping based on the coincidence.

Parameters:

right - the right source of elements

leftDurationSelector - the duration selector for a left element

rightDurationSelector - the duration selector for a right element

resultSelector - the selector which will produce the output value

Returns:

the new observable

See Also:

#groupJoin(Observable, Observable, Func1, Func1, Func2)

last

public T last()

Returns the last element of the source observable or throws NoSuchElementException if the source is empty or the wait is interrupted.

Exception semantics: the exceptions thrown by the source are ignored and treated as termination signals.

The difference between this and the wait operator is that it returns the last valid value from before an error or finish, ignoring any exceptions.

Returns:

the last element

last

public T last(@Nonnull
              Func0<? extends T> defaultSupplier)

Returns the last element of the source observable or the supplier's value if the source is empty.

Exception semantics: the exceptions thrown by the source are ignored and treated as termination signals.

Parameters:

defaultSupplier - the function to provide the default value

Returns:

the last element

Since:

0.97

last

public T last(T defaultValue)

Returns the last element of the source observable or the default value if the source is empty.

Exception semantics: the exceptions thrown by the source are ignored and treated as termination signals.

Parameters:

defaultValue - the value to provide if the source is empty

Returns:

the last element

Since:

0.97

lastAsync

@Nonnull
public ObservableBuilder<T> lastAsync()

Returns an observable which relays the last element of the source observable or throws a NoSuchElementException() if the source is empty.

Exception semantics: errors from source are propagated as-is.

Returns:

the new observable

Since:

0.97

lastAsync

@Nonnull
public ObservableBuilder<T> lastAsync(@Nonnull
                                                Func0<? extends T> defaultSupplier)

Returns an observable which relays the last element of the source observable or the supplier's value if the source is empty.

Exception semantics: errors from source are propagated as-is.

Parameters:

defaultSupplier - the supplier to produce a value to return in case the source is empty

Returns:

the new observable

Since:

0.97

lastAsync

@Nonnull
public ObservableBuilder<T> lastAsync(T defaultValue)

Returns an observable which relays the last element of the source observable or the default value if the source is empty.

Exception semantics: errors from source are propagated as-is.

Parameters:

defaultValue - the default value to return in case the source is empty

Returns:

the new observable

Since:

0.97

latest

@Nonnull
public IterableBuilder<T> latest()

Returns an iterable which returns values on a momentary basis from the source. Useful when source produces values at different rate than the consumer takes it. The iterable.next() call might block until the first value becomes available or something else happens in the observable

Returns:

the iterable

manySelect

@Nonnull
public <U> ObservableBuilder<U> manySelect(@Nonnull
                                                     Func1<? super Observable<T>,? extends Observable<U>> selector)

For each of the source elements, creates a view of the source starting with the given element and calls the selector function. The function's return observable is then merged into a single observable sequence.

For example, a source sequence of (1, 2, 3) will create three function calls with (1, 2, 3), (2, 3) and (3) as a content.

Type Parameters:

U - the result element type

Parameters:

selector - the selector function

Returns:

the new observable

manySelect

@Nonnull
public <U> ObservableBuilder<U> manySelect(@Nonnull
                                                     Func1<? super Observable<T>,? extends U> selector,
                                                     @Nonnull
                                                     Scheduler scheduler)

For each value of the source observable, it creates a view starting from that value into the source and calls the given selector function asynchronously on the given scheduler. The result of that computation is then transmitted to the observer.

It is sometimes called the comonadic bind operator and compared to the ContinueWith semantics.

Type Parameters:

U - the result element type

Parameters:

selector - the selector that extracts an U from the series of Ts.

scheduler - the scheduler where the extracted U will be emmitted from.

Returns:

the new observable.

manySelect0

@Nonnull
public <U> ObservableBuilder<U> manySelect0(@Nonnull
                                                      Func1<? super Observable<T>,? extends U> selector)

Uses the selector function on the given source observable to extract a single value and send this value to the registered observer. It is sometimes called the comonadic bind operator and compared to the ContinueWith semantics. The default scheduler is used to emit the output value

Type Parameters:

U - the output type

Parameters:

selector - the selector that extracts an U from the series of Ts.

Returns:

the new observable.

materialize

@Nonnull
public ObservableBuilder<Option<T>> materialize()

Returns an observable which converts all messages to an Option value. The returned observable does not itself signal error or finish. Its dual is the dematerialize method.

Returns:

the new observable

See Also:

#dematerialize(Observable)

max

@Nonnull
public <U extends java.lang.Comparable<? super U>> ObservableBuilder<U> max()

Returns the maximum value encountered in the source observable onse it finish().

Type Parameters:

U - the element type which must be comparable to itself

Returns:

the the maximum value

max

@Nonnull
public ObservableBuilder<T> max(@Nonnull
                                          java.util.Comparator<T> comparator)

Returns the maximum value encountered in the source observable onse it finish().

Parameters:

comparator - the comparator to decide the relation of values

Returns:

the the maximum value

See Also:

Functions.asComparator(Func2)

maxBy

@Nonnull
public <Key extends java.lang.Comparable<? super Key>> ObservableBuilder<java.util.List<T>> maxBy(@Nonnull
                                                                                                            Func1<? super T,? extends Key> keyExtractor)

Returns an observable which provides with the list of Ts which had their keys as maximums. The returned observer may finish() if the source sends finish() without any next(). The generated list is modifiable.

Type Parameters:

Key - the key type, which must be comparable to itself

Parameters:

keyExtractor - the key extractor to produce Keys from Ts.

Returns:

the observable for the maximum keyed Ts

maxBy

@Nonnull
public <Key> ObservableBuilder<java.util.List<T>> maxBy(@Nonnull
                                                                  Func1<? super T,? extends Key> keyExtractor,
                                                                  @Nonnull
                                                                  java.util.Comparator<? super Key> keyComparator)

Returns an observable which provides with the list of Ts which had their keys as maximums. The returned observer may finish() if the source sends finish() without any next(). The generated list is modifiable.

Type Parameters:

Key - the key type

Parameters:

keyExtractor - the key extractor to produce Keys from Ts.

keyComparator - the comparator for the keys

Returns:

the observable for the maximum keyed Ts

merge

@Nonnull
public ObservableBuilder<T> merge(@Nonnull
                                            java.lang.Iterable<? extends Observable<? extends T>> sources)

Combines the notifications of all sources. The resulting stream of Ts might come from any of the sources.

Parameters:

sources - the list of sources

Returns:

the observable

merge

@Nonnull
public ObservableBuilder<T> merge(@Nonnull
                                            Observable<? extends T> second)

Merge the events of two observable sequences.

Parameters:

second - the second observable

Returns:

the merged observable

mergeAll

@Nonnull
public ObservableBuilder<T> mergeAll(@Nonnull
                                               Observable<? extends Observable<T>> sources)

Merge the dynamic sequence of observables of T.

Exception semantics: if the sources or any inner observer signals an error, the outer observable will signal that error and all active source observers are terminated.

Parameters:

sources - the observable sequence of observable sequence of Ts

Returns:

the new observable

min

@Nonnull
public <U extends java.lang.Comparable<? super U>> ObservableBuilder<U> min()

Returns the minimum value encountered in the source observable onse it finish().

Type Parameters:

U - the self comparable element type

Returns:

the the minimum value

min

@Nonnull
public ObservableBuilder<T> min(@Nonnull
                                          java.util.Comparator<? super T> comparator)

Returns the minimum value encountered in the source observable onse it finish().

Parameters:

comparator - the comparator to decide the relation of values

Returns:

the the minimum value

See Also:

Functions.asComparator(Func2)

minBy

@Nonnull
public <Key extends java.lang.Comparable<? super Key>> ObservableBuilder<java.util.List<T>> minBy(@Nonnull
                                                                                                            Func1<? super T,? extends Key> keyExtractor)

Returns an observable which provides with the list of Ts which had their keys as minimums. The returned observer may finish() if the source sends finish() without any next(). The generated list is modifiable.

Type Parameters:

Key - the key type, which must be comparable to itself

Parameters:

keyExtractor - the key extractor to produce Keys from Ts.

Returns:

the observable for the minimum keyed Ts

minBy

@Nonnull
public <Key> ObservableBuilder<java.util.List<T>> minBy(@Nonnull
                                                                  Func1<T,Key> keyExtractor,
                                                                  @Nonnull
                                                                  java.util.Comparator<Key> keyComparator)

Returns an observable which provides with the list of Ts which had their keys as minimums. The returned observer may finish() if the source sends finish() without any next(). The generated list is modifiable.

Type Parameters:

Key - the key type

Parameters:

keyExtractor - the key extractor to produce Keys from Ts.

keyComparator - the comparator for the keys

Returns:

the observable for the minimum keyed Ts

See Also:

Functions.asComparator(Func2)

mostRecent

@Nonnull
public IterableBuilder<T> mostRecent(T initialValue)

Samples the latest T value coming from the source observable or the initial value when no messages arrived so far. If the producer and consumer run on different speeds, the consumer might receive the same value multiple times. The iterable sequence terminates if the source finishes or returns an error.

The returned iterator throws UnsupportedOperationException for its remove() method.

Parameters:

initialValue - the initial value to return until the source actually produces something.

Returns:

the iterable

multicast

@Nonnull
public <U,V> Observable<V> multicast(@Nonnull
                                               Func0<? extends Subject<? super T,? extends U>> subjectSelector,
                                               @Nonnull
                                               Func1<? super Observable<? extends U>,? extends Observable<? extends V>> selector)

Multicasts the source events through the subject instantiated via the subjectSelector. Each subscription to this sequence causes a separate multicast invocation.

Type Parameters:

U - the element type of the intermediate subject's output

V - the result type

Parameters:

subjectSelector - the factory function to create an intermediate subject which through the source values will be multicasted.

selector - the factory method to use the multicasted subject and enforce some policies on it

Returns:

the observable sequence that contains all elements of the multicasted functions

multicast

@Nonnull
public <U> ObservableBuilder<U> multicast(@Nonnull
                                                    Observer<? super T> observer,
                                                    Observable<? extends U> observable)

Returns an observable which remains connected to the source observable as long as there is at least one registration to this output observable.

The observer and observable parameters should denote the same object which implements both Observable and Observer interfaces.

Type Parameters:

U - the result element type

Parameters:

observer - the observer that listens for Ts. Should be the same object as observable.

observable - the observable that will produce Us. Should be the same object as observable.

Returns:

the new observable

never

@Nonnull
public ObservableBuilder<T> never()

Returns an observable which never fires.

Returns:

the observable

next

@Nonnull
public IterableBuilder<T> next()

Returns an iterable sequence which blocks until an element becomes available from the source. The iterable's (has)next() call is paired up with the observer's next() call, therefore, values might be skipped if the iterable is not on its (has)next() call at the time of reception.

The returned iterator will throw an UnsupportedOperationException for its remove() method.

Exception semantics: in case of exception received, the source is disconnected and the exception is rethrown from the iterator's next method as a wrapped RuntimeException if necessary.

Returns:

the iterable

observeOn

@Nonnull
public ObservableBuilder<T> observeOn(@Nonnull
                                                Scheduler pool)

Wrap the given observable object in a way that any of its observers receive callbacks on the given thread pool.

Parameters:

pool - the target observable

Returns:

the new observable

ofType

@Nonnull
public <U> ObservableBuilder<U> ofType(@Nonnull
                                                 java.lang.Class<U> clazz)

Filters the elements of the source sequence which is assignable to the provided type.

Type Parameters:

U - the target element type

Parameters:

clazz - the class token

Returns:

the filtering obserable since 0.97

orderBy

@Nonnull
public <U extends java.lang.Comparable<? super U>> ObservableBuilder<U> orderBy()

Returns an Observable which traverses the entire source Observable and creates an ordered list of elements. Once the source Observable completes, the elements are streamed to the output.

Type Parameters:

U - the source element type, must be self comparable

Returns:

the new iterable

orderBy

@Nonnull
public ObservableBuilder<T> orderBy(@Nonnull
                                              java.util.Comparator<? super T> comparator)

Returns an Observable which traverses the entire source Observable and creates an ordered list of elements. Once the source Observable completes, the elements are streamed to the output.

Parameters:

comparator - the value comparator

Returns:

the new iterable

orderBy

@Nonnull
public <U extends java.lang.Comparable<? super U>> ObservableBuilder<T> orderBy(@Nonnull
                                                                                          Func1<? super T,? extends U> keySelector)

Returns an Observable which traverses the entire source Observable and creates an ordered list of elements. Once the source Observable completes, the elements are streamed to the output.

Type Parameters:

U - the key type for the ordering, must be self comparable

Parameters:

keySelector - the key selector for comparison

Returns:

the new iterable

orderBy

@Nonnull
public <U> ObservableBuilder<T> orderBy(@Nonnull
                                                  Func1<? super T,? extends U> keySelector,
                                                  @Nonnull
                                                  java.util.Comparator<? super U> keyComparator)

Returns an Observable which traverses the entire source Observable and creates an ordered list of elements. Once the source iterator completes, the elements are streamed to the output.

Note that it buffers the elements of source until it signals finish.

Exception semantics: the exception is relayed and no ordering is performed.

Completion semantics: the output terminates when the source terminates and the sorted values are all submitted.

Type Parameters:

U - the key type for the ordering

Parameters:

keySelector - the key selector for comparison

keyComparator - the key comparator function

Returns:

the new iterable

print

public void print()

Runs this observable and prints the values.

Is the same as using this.run(Reactive.print()).

println

public void println()

Runs this observable and prints the values.

Is the same as using this.run(Reactive.println()).

prune

public ObservableBuilder<T> prune()

Returns an observable which shares all registration to the source observable and each observer will only see the last notification.

Basically a replay with buffer size 1.

Returns:

the observable

prune

@Nonnull
public <U> ObservableBuilder<U> prune(@Nonnull
                                                Func1<? super Observable<? extends T>,? extends Observable<U>> selector)

Returns an observable which shares all registration to the source observable and each observer will only see the last notification.

Basically a replay with buffer size 1.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

Returns:

the observable

prune

@Nonnull
public <U> ObservableBuilder<U> prune(@Nonnull
                                                Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                @Nonnull
                                                Scheduler scheduler)

Returns an observable which shares all registration to the source observable and each observer will only see the last notification.

Basically a replay with buffer size 1.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

scheduler - the scheduler for replaying the single value

Returns:

the observable

prune

@Nonnull
public ObservableBuilder<T> prune(@Nonnull
                                            Scheduler scheduler)

Returns an observable which shares all registration to the source observable and each observer will only see the last notification.

Basically a replay with buffer size 1.

Parameters:

scheduler - the scheduler for replaying the single value

Returns:

the observable

publish

@Nonnull
public ObservableBuilder<T> publish()

Returns an observable which shares a single subscription to the underlying source.

This is a specialization of the multicast operator with a simple forwarding subject.

Returns:

the new observable

See Also:

Reactive.publish(Observable)

publish

@Nonnull
public <U> ObservableBuilder<U> publish(@Nonnull
                                                  Func1<? super Observable<? extends T>,? extends Observable<? extends U>> selector)

Returns an observable sequence which is the result of invoking the selector on a connectable observable sequence that shares a single subscription with the underlying source observable.

This is a specialization of the multicast operator with a regular subject on U.

Type Parameters:

U - the result element type

Parameters:

selector - the observable selector that can use the source sequence as many times as necessary, without multiple registration.

Returns:

the observable sequence

publish

@Nonnull
public <U> ObservableBuilder<U> publish(@Nonnull
                                                  Func1<? super Observable<? extends T>,? extends Observable<? extends U>> selector,
                                                  T initialValue)

Returns an observable sequence which is the result of invoking the selector on a connectable observable sequence that shares a single subscription with the underlying source observable and registering parties receive the initial value immediately.

This is a specialization of the multicast operator with a regular subject on U.

Type Parameters:

U - the result element type

Parameters:

selector - the observable selector that can use the source sequence as many times as necessary, without multiple registration.

initialValue - the value received by registering parties immediately.

Returns:

the observable sequence

publish

@Nonnull
public ObservableBuilder<T> publish(T initialValue)

Returns an observable which shares a single subscription to the underlying source and starts with with the initial value.

Registering parties will immediately receive the initial value but the subsequent values depend upon wether the observer is connected or not.

This is a specialization of the multicast operator with a simple forwarding subject.

Parameters:

initialValue - the initial value the observers will receive when registering

Returns:

the new observable

publishLast

@Nonnull
public ObservableBuilder<T> publishLast()

Returns a connectable observable which uses a single registration to the underlying source sequence containing only the last value.

Returns:

the new observable

Since:

0.97

See Also:

Reactive.publish(Observable)

publishLast

@Nonnull
public <U> ObservableBuilder<U> publishLast(@Nonnull
                                                      Func1<? super Observable<? extends T>,? extends Observable<? extends U>> selector)

Retunrs an observable that is the result of the selector invocation on a connectable observable that shares a single registration to source and returns the last event of the source.

Type Parameters:

U - the result type

Parameters:

selector - function that can use the multicasted source as many times as necessary without causing new registrations to source

Returns:

the new observable

Since:

0.97

See Also:

Reactive.publishLast(Observable, Func1)

refCount

@Nonnull
public ObservableBuilder<T> refCount()

Returns an observable sequence which connects to the source for the first registered party and stays connected to the source as long as there is at least one registered party to it.

The wrapped observable of this builder must implement ConnectableObservable, or else an UnsupportedOperationException is thrown

Returns:

the observable sequence.

Since:

0.97

See Also:

Reactive.refCount(ConnectableObservable)

register

@Nonnull
public java.io.Closeable register(@Nonnull
                                            java.util.Observer javaObserver)

Registers a java-observer with this reactive-observable instance.

Parameters:

javaObserver - the java observer to register

Returns:

the close handler

register

@Nonnull
public java.io.Closeable register(@Nonnull
                                            Observer<? super T> observer)

Description copied from interface: Observable

Registers an observer for the notification of Ts.

Specified by:

register in interface Observable<T>

Parameters:

observer - the observer of Ts or any supertype of it

Returns:

the way of deregister the observer from this provider

registerOn

@Nonnull
public ObservableBuilder<T> registerOn(@Nonnull
                                                 Scheduler pool)

Wrap the given observable into an new Observable instance, which calls the original register() method on the supplied pool.

Parameters:

pool - the pool to perform the original subscribe() call

Returns:

the new observable

relayUntil

@Nonnull
public ObservableBuilder<T> relayUntil(@Nonnull
                                                 Func0<java.lang.Boolean> condition)

Relay values of T while the given condition does not hold. Once the condition turns true the relaying stops.

Parameters:

condition - the condition that must be false to relay Ts

Returns:

the new observable

relayWhile

@Nonnull
public ObservableBuilder<T> relayWhile(@Nonnull
                                                 Func0<java.lang.Boolean> condition)

Relay the stream of Ts until condition turns into false.

Parameters:

condition - the condition that must hold to relay Ts

Returns:

the new observable

removeTimeInterval

@Nonnull
public ObservableBuilder<T> removeTimeInterval()

Unwrap the values within a timeinterval observable to its normal value.

Returns:

the raw observables of Ts

removeTimestamped

@Nonnull
public ObservableBuilder<T> removeTimestamped()

Unwrap the values within a timestamped observable to its normal value.

Returns:

the raw observables of Ts

repeat

@Nonnull
public ObservableBuilder<T> repeat()

Repeat the source observable indefinitely.

Returns:

the new observable

Since:

0.97

See Also:

Reactive.repeat(Observable)

repeat

@Nonnull
public ObservableBuilder<T> repeat(int count)

Repeat the source observable count times.

Parameters:

count - the number of times to repeat

Returns:

the new observable

replay

@Nonnull
public ObservableBuilder<T> replay()

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.

Returns:

the new observable

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                 int bufferSize)

Creates an observable which shares the source observable and replays the buffered source Ts to any of the registering observers.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

bufferSize - the target buffer size

Returns:

the new observable

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                 int bufferSize,
                                                 long timeSpan,
                                                 @Nonnull
                                                 java.util.concurrent.TimeUnit unit)

Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

bufferSize - the buffer size

timeSpan - the window length

unit - the time unit

Returns:

the new observer

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                 int bufferSize,
                                                 long timeSpan,
                                                 @Nonnull
                                                 java.util.concurrent.TimeUnit unit,
                                                 @Nonnull
                                                 Scheduler scheduler)

Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

bufferSize - the buffer size

timeSpan - the window length

unit - the time unit

scheduler - the target scheduler

Returns:

the new observer

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                 int bufferSize,
                                                 @Nonnull
                                                 Scheduler scheduler)

Creates an observable which shares the source observable returned by the selector and replays all source Ts to any of the registering observers.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

bufferSize - the target buffer size

scheduler - the scheduler from where the historical elements are emitted

Returns:

the new observable

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                 long timeSpan,
                                                 @Nonnull
                                                 java.util.concurrent.TimeUnit unit)

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

timeSpan - the window length

unit - the time unit

Returns:

the new observer

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<? extends T>,? extends Observable<U>> selector,
                                                 long timeSpan,
                                                 @Nonnull
                                                 java.util.concurrent.TimeUnit unit,
                                                 @Nonnull
                                                 Scheduler scheduler)

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Type Parameters:

U - the return element type

Parameters:

selector - the output stream selector

timeSpan - the window length

unit - the time unit

scheduler - the target scheduler

Returns:

the new observer

replay

@Nonnull
public <U> ObservableBuilder<U> replay(@Nonnull
                                                 Func1<? super Observable<T>,? extends Observable<U>> selector)

Returns the observable sequence for the supplied source observable by invoking the selector function with it.

Type Parameters:

U - the output element type

Parameters:

selector - the selector which returns an observable of Us for the given source

Returns:

the new observable

replay

@Nonnull
public ObservableBuilder<T> replay(int bufferSize)

Creates an observable which shares the source observable and replays the buffered source Ts to any of the registering observers.

Parameters:

bufferSize - the target buffer size

Returns:

the new observable

replay

@Nonnull
public ObservableBuilder<T> replay(int bufferSize,
                                             long timeSpan,
                                             java.util.concurrent.TimeUnit unit)

Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Parameters:

bufferSize - the buffer size

timeSpan - the window length

unit - the time unit

Returns:

the new observer

replay

@Nonnull
public ObservableBuilder<T> replay(int bufferSize,
                                             long timeSpan,
                                             @Nonnull
                                             java.util.concurrent.TimeUnit unit,
                                             @Nonnull
                                             Scheduler scheduler)

Creates an observable which shares the source observable and replays the bufferSize source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Parameters:

bufferSize - the buffer size

timeSpan - the window length

unit - the time unit

scheduler - the target scheduler

Returns:

the new observer

replay

@Nonnull
public ObservableBuilder<T> replay(int bufferSize,
                                             @Nonnull
                                             Scheduler scheduler)

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.

Parameters:

bufferSize - the target buffer size

scheduler - the scheduler from where the historical elements are emitted

Returns:

the new observable

replay

@Nonnull
public ObservableBuilder<T> replay(long timeSpan,
                                             @Nonnull
                                             java.util.concurrent.TimeUnit unit)

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Parameters:

timeSpan - the window length

unit - the time unit

Returns:

the new observer

replay

@Nonnull
public ObservableBuilder<T> replay(long timeSpan,
                                             @Nonnull
                                             java.util.concurrent.TimeUnit unit,
                                             @Nonnull
                                             Scheduler scheduler)

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers. After the periodic timespan, the buffer is reset.

Parameters:

timeSpan - the window length

unit - the time unit

scheduler - the target scheduler

Returns:

the new observer

replay

@Nonnull
public ObservableBuilder<T> replay(@Nonnull
                                             Scheduler scheduler)

Creates an observable which shares the source observable and replays all source Ts to any of the registering observers.

Parameters:

scheduler - the scheduler from where the historical elements are emitted

Returns:

the new observable

resumeAlways

@Nonnull
public ObservableBuilder<T> resumeAlways(@Nonnull
                                                   java.lang.Iterable<? extends Observable<? extends T>> sources)

Returns an observable which listens to elements from a source until it signals an error() or finish() and continues with the next observable. The registration happens only when the previous observables finished in any way.

Parameters:

sources - the list of observables

Returns:

the observable

resumeConditionally

@Nonnull
public ObservableBuilder<T> resumeConditionally(@Nonnull
                                                          Func1<? super java.lang.Throwable,? extends Observable<? extends T>> handler)

Continues the observable sequence in case of exception whith the sequence provided by the function for that particular exception.

Exception semantics: in case of an exception in source, the exception is turned into a continuation, but the second observable's error now terminates the sequence.

Note: Rx calls this Catch.

Parameters:

handler - The exception handler

Returns:

the new observable

Since:

0.97

resumeOnError

@Nonnull
public ObservableBuilder<T> resumeOnError(@Nonnull
                                                    java.lang.Iterable<? extends Observable<? extends T>> sources)

It tries to submit the values of first observable, but when it throws an exeption, the next observable within source is used further on. Basically a failover between the Observables. If the current source finish() then the result observable calls finish(). If the last of the sources calls error() the result observable calls error()

Parameters:

sources - the available source observables.

Returns:

the failover observable

retry

@Nonnull
public ObservableBuilder<T> retry()

Restarts the observation until the source observable terminates normally.

Returns:

the repeating observable

retry

@Nonnull
public ObservableBuilder<T> retry(int count)

Restarts the observation until the source observable terminates normally or the count retry count was used up.

Parameters:

count - the retry count

Returns:

the repeating observable

run

public void run()
         throws java.lang.InterruptedException

Blocks until the observable calls finish() or error(). Values are ignored.

Throws:

java.lang.InterruptedException - if the current thread is interrupted while waiting on the observable.

run

public void run(@Nonnull
                Action1<? super T> action)
         throws java.lang.InterruptedException

Blocks until the observable calls finish() or error(). Values are submitted to the given action.

Parameters:

action - the action to invoke for each value

Throws:

java.lang.InterruptedException - if the current thread is interrupted while waiting on the observable.

run

public void run(@Nonnull
                Observer<? super T> observer)
         throws java.lang.InterruptedException

Blocks until the observable calls finish() or error(). Events are submitted to the given observer.

Parameters:

observer - the observer to invoke for each event

Throws:

java.lang.InterruptedException - if the current thread is interrupted while waiting on the observable.

sample

@Nonnull
public ObservableBuilder<T> sample(long time,
                                             @Nonnull
                                             java.util.concurrent.TimeUnit unit)

Periodically sample the given source observable, which means tracking the last value of the observable and periodically submitting it to the output observable.

Parameters:

time - the time value to wait

unit - the time unit

Returns:

the sampled observable

sample

@Nonnull
public ObservableBuilder<T> sample(long time,
                                             @Nonnull
                                             java.util.concurrent.TimeUnit unit,
                                             @Nonnull
                                             Scheduler pool)

Periodically sample the given source observable, which means tracking the last value of the observable and periodically submitting it to the output observable.

Parameters:

time - the time value to wait

unit - the time unit

pool - the scheduler pool where the periodic submission should happen.

Returns:

the sampled observable

sample

@Nonnull
public <U> ObservableBuilder<T> sample(@Nonnull
                                                 Observable<? extends U> sampler)

Samples the observable sequence when the other sequence fires an event. The sampling is terminated if any of the sequences finish.

Exception semantics: exceptions raised anywhere will terminate the sequences.

Type Parameters:

U - the sampler's element type, irrelevant

Parameters:

sampler - the sampler sequence

Returns:

the sampled value sequence

Since:

0.97

scan

@Nonnull
public ObservableBuilder<T> scan(@Nonnull
                                           Func2<? super T,? super T,? extends T> accumulator)

Creates an observable which accumultates the given source and submits each intermediate results to its subscribers. Example:
range(0, 5).accumulate((x, y) => x + y) produces a sequence of [0, 1, 3, 6, 10];
basically the first event (0) is just relayed and then every pair of values are simply added together and relayed

Parameters:

accumulator - the accumulator which takest the current accumulation value and the current observed value and returns a new accumulated value

Returns:

the observable

scan

@Nonnull
public ObservableBuilder<T> scan(T seed,
                                           @Nonnull
                                           Func2<? super T,? super T,? extends T> accumulator)

Creates an observable which accumultates the given source and submits each intermediate results to its subscribers. Example:
range(0, 5).accumulate(1, (x, y) => x + y) produces a sequence of [1, 2, 4, 7, 11];
basically the accumulation starts from zero and the first value (0) that comes in is simply added

Parameters:

seed - the initial value of the accumulation

accumulator - the accumulator which takest the current accumulation value and the current observed value and returns a new accumulated value

Returns:

the observable

select

@Nonnull
public <U> ObservableBuilder<U> select(@Nonnull
                                                 Func1<? super T,? extends U> mapper)

Use the mapper to transform the T source into an U source.

Type Parameters:

U - the type of the new observable

Parameters:

mapper - the mapper from Ts to Us

Returns:

the observable on Us

select

@Nonnull
public <U> ObservableBuilder<U> select(@Nonnull
                                                 Func2<? super T,? super java.lang.Integer,? extends U> selector)

Transforms the elements of the source observable into Us by using a selector which receives an index indicating how many elements have been transformed this far.

Type Parameters:

U - the output element type

Parameters:

selector - the selector taking an index and the current T

Returns:

the transformed observable

selectLong

@Nonnull
public <U> ObservableBuilder<U> selectLong(@Nonnull
                                                     Func2<? super T,? super java.lang.Long,? extends U> selector)

Transforms the elements of the source observable into Us by using a selector which receives a long index indicating how many elements have been transformed this far.

Type Parameters:

U - the output element type

Parameters:

selector - the selector taking an index and the current T

Returns:

the transformed observable

Since:

0.97

selectMany

@Nonnull
public <U> ObservableBuilder<U> selectMany(@Nonnull
                                                     Func1<? super T,? extends Observable<? extends U>> selector)

Transform the given source of Ts into Us in a way that the selector might return an observable ofUs for a single T. The observable is fully channelled to the output observable.

Type Parameters:

U - the output element type

Parameters:

selector - the selector to return an Iterable of Us

Returns:

the

selectMany

@Nonnull
public <U,V> ObservableBuilder<V> selectMany(@Nonnull
                                                       Func1<? super T,? extends Observable<? extends U>> collectionSelector,
                                                       @Nonnull
                                                       Func2<? super T,? super U,? extends V> resultSelector)

Creates an observable in which for each of Ts an observable of Vs are requested which in turn will be transformed by the resultSelector for each pair of T and V giving an U.

Type Parameters:

U - the intermediate element type

V - the output element type

Parameters:

collectionSelector - the selector which returns an observable of intermediate Vs

resultSelector - the selector which gives an U for a T and V

Returns:

the observable of Us

selectMany

@Nonnull
public <U> ObservableBuilder<U> selectMany(@Nonnull
                                                     Observable<? extends U> provider)

Creates an observable of Us in a way when a source T arrives, the observable of Us is completely drained into the output. This is done again and again for each arriving Ts.

Type Parameters:

U - the output type

Parameters:

provider - the source of Us

Returns:

the observable for Us

selectManyIterable

@Nonnull
public <U> ObservableBuilder<U> selectManyIterable(@Nonnull
                                                             Func1<? super T,? extends java.lang.Iterable<? extends U>> selector)

Transform the given source of Ts into Us in a way that the selector might return zero to multiple elements of Us for a single T. The iterable is flattened and submitted to the output

Type Parameters:

U - the output element type

Parameters:

selector - the selector to return an Iterable of Us

Returns:

the

selectManyIterable

@Nonnull
public <U,V> Observable<V> selectManyIterable(@Nonnull
                                                        Func1<? super T,? extends java.lang.Iterable<? extends U>> selector,
                                                        @Nonnull
                                                        Func2<? super T,? super U,? extends V> resultSelector)

Transform the given source of Ts into Us in a way that the selector might return zero to multiple elements of Us for a single T. The iterable is flattened and submitted to the output

Type Parameters:

U - the intermediate type of

V - the output type

Parameters:

selector - the selector to return an Iterable of Us

resultSelector - the selector for a pair of T and U

Returns:

the observable of Vs

Since:

0.97

sequenceEqual

@Nonnull
public ObservableBuilder<java.lang.Boolean> sequenceEqual(@Nonnull
                                                                    Observable<? extends T> second)

Compares two sequences and returns whether they are produce the same elements in terms of the null-safe object equality.

The equality only stands if the two sequence produces the same amount of values and those values are pairwise equal. If one of the sequences terminates before the other, the equality test will return false.

Parameters:

second - the second source of Ts

Returns:

the new observable

sequenceEqual

@Nonnull
public ObservableBuilder<java.lang.Boolean> sequenceEqual(@Nonnull
                                                                    Observable<? extends T> second,
                                                                    @Nonnull
                                                                    Func2<? super T,? super T,java.lang.Boolean> comparer)

Compares two sequences and returns whether they are produce the same elements in terms of the comparer function.

The equality only stands if the two sequence produces the same amount of values and those values are pairwise equal. If one of the sequences terminates before the other, the equality test will return false.

Parameters:

second - the second source of Ts

comparer - the equality comparison function

Returns:

the new observable

single

public T single()

Returns the single element of the given observable source. If the source is empty, a NoSuchElementException is thrown. If the source has more than one element, a TooManyElementsException is thrown.

Returns:

the single element

single

public T single(@Nonnull
                Func0<? extends T> defaultSupplier)

Returns the single element of the given observable source, returns the supplier's value if the source is empty or throws a TooManyElementsException in case the source has more than one item.

Parameters:

defaultSupplier - the function that produces the default value

Returns:

the single element

Since:

0.97

See Also:

#first(Observable, Func0)

single

public T single(T defaultValue)

Returns the single element of the given observable source, returns the default if the source is empty or throws a TooManyElementsException in case the source has more than one item.

Parameters:

defaultValue - the value to return if the source is empty

Returns:

the single element

Since:

0.97

See Also:

#first(Observable, Object)

singleAsync

@Nonnull
public ObservableBuilder<T> singleAsync()

Returns the only element of the source or throws NoSuchElementException if the source is empty or TooManyElementsException if it contains more than one elements.

Returns:

the new observable

Since:

0.97

singleAsync

@Nonnull
public ObservableBuilder<T> singleAsync(@Nonnull
                                                  Func0<? extends T> defaultSupplier)

Returns the only element of the source, returns the supplier's value if the source is empty or TooManyElementsException if it contains more than one elements.

Parameters:

defaultSupplier - the function that produces

Returns:

the new observable

Since:

0.97

singleAsync

@Nonnull
public ObservableBuilder<T> singleAsync(T defaultValue)

Returns the only element of the source, returns the default value if the source is empty or TooManyElementsException if it contains more than one elements.

Parameters:

defaultValue - the default value to return in case the source is empty

Returns:

the new observable

Since:

0.97

skip

@Nonnull
public ObservableBuilder<T> skip(int count)

Skips the given amount of next() messages from source and relays the rest.

Parameters:

count - the number of messages to skip

Returns:

the new observable

skip

@Nonnull
public ObservableBuilder<T> skip(long time,
                                           @Nonnull
                                           java.util.concurrent.TimeUnit unit)

Skips elements of the source observable for the specified amount of time.

Exceptions are always forwarded immediately, even if it occurs before the skip time runs out.

Parameters:

time - the time to wait

unit - the unit

Returns:

the new observable

Since:

0.97

skip

@Nonnull
public ObservableBuilder<T> skip(long time,
                                           @Nonnull
                                           java.util.concurrent.TimeUnit unit,
                                           @Nonnull
                                           Scheduler pool)

Skips elements of the source observable for the specified amount of time.

Exceptions are always forwarded immediately, even if it occurs before the skip time runs out.

Parameters:

time - the time to wait

unit - the unit

pool - the scheduler

Returns:

the new observable

Since:

0.97

skipLast

@Nonnull
public ObservableBuilder<T> skipLast(int count)

Skips the last count elements from the source observable.

Parameters:

count - the number of elements to skip at the end

Returns:

the new observable

skipLast

@Nonnull
public ObservableBuilder<T> skipLast(long time,
                                               @Nonnull
                                               java.util.concurrent.TimeUnit unit)

Skips the elements from the end for the specified amount of time.

Since there is no way to know the total duration of the sequence, the operator queues elements unit they become older than the specified time, causing the elements to be delayed by time.

Parameters:

time - the time to skip from last

unit - the time unit

Returns:

the new observable

Since:

0.97

skipUntil

@Nonnull
public <U> ObservableBuilder<T> skipUntil(@Nonnull
                                                    Observable<? extends U> signaller)

Skip the source elements until the signaller sends its first element.

Type Parameters:

U - the element type of the signaller, irrelevant

Parameters:

signaller - the source of Us

Returns:

the new observable

skipWhile

@Nonnull
public ObservableBuilder<T> skipWhile(@Nonnull
                                                Func1<? super T,java.lang.Boolean> condition)

Skips the Ts from source while the specified condition returns true. If the condition returns false, all subsequent Ts are relayed, ignoring the condition further on. Errors and completion is relayed regardless of the condition.

Parameters:

condition - the condition that must turn false in order to start relaying

Returns:

the new observable

skipWhile

@Nonnull
public ObservableBuilder<T> skipWhile(@Nonnull
                                                Func2<? super T,? super java.lang.Integer,java.lang.Boolean> condition)

Skips the Ts from source while the specified indexed condition returns true. If the condition returns false, all subsequent Ts are relayed, ignoring the condition further on. Errors and completion is relayed regardless of the condition.

Parameters:

condition - the condition that must turn false in order to start relaying

Returns:

the new observable

Since:

0.97

skipWhileLong

@Nonnull
public ObservableBuilder<T> skipWhileLong(@Nonnull
                                                    Func2<? super T,? super java.lang.Long,java.lang.Boolean> condition)

Skips the Ts from source while the specified long indexed condition returns true. If the condition returns false, all subsequent Ts are relayed, ignoring the condition further on. Errors and completion is relayed regardless of the condition.

Parameters:

condition - the condition that must turn false in order to start relaying

Returns:

the new observable

Since:

0.97

startWith

@Nonnull
public ObservableBuilder<T> startWith(@Nonnull
                                                java.lang.Iterable<? extends T> values)

Start with the given iterable of values before relaying the Ts from the source. The iterable values are emmitted on the default pool.

Parameters:

values - the values to start with

Returns:

the new observable

startWith

@Nonnull
public ObservableBuilder<T> startWith(@Nonnull
                                                java.lang.Iterable<? extends T> values,
                                                @Nonnull
                                                Scheduler pool)

Start with the given iterable of values before relaying the Ts from the source. The iterable values are emmitted on the given pool.

Parameters:

values - the values to start with

pool - the pool where the iterable values should be emitted

Returns:

the new observable

startWith

@Nonnull
public ObservableBuilder<T> startWith(@Nonnull
                                                Scheduler pool,
                                                T... values)

Start with the given iterable of values before relaying the Ts from the source. The value is emmitted on the given pool.

Parameters:

pool - the pool where the iterable values should be emitted

values - the values to start with

Returns:

the new observable

startWith

@Nonnull
public ObservableBuilder<T> startWith(@Nonnull
                                                T... values)

Start with the given iterable of values before relaying the Ts from the source. The iterable values are emmitted on the default pool.

Parameters:

values - the values to start with

Returns:

the new observable

sumBigDecimal

@Nonnull
public ObservableBuilder<java.math.BigDecimal> sumBigDecimal()

Computes and signals the sum of the values of the BigDecimal source. The source may not send nulls.

Returns:

the observable for the sum value

sumBigInteger

@Nonnull
public ObservableBuilder<java.math.BigInteger> sumBigInteger()

Computes and signals the sum of the values of the BigInteger source. The source may not send nulls.

Returns:

the observable for the sum value

sumDouble

@Nonnull
public ObservableBuilder<java.lang.Double> sumDouble()

Computes and signals the sum of the values of the Double source. The source may not send nulls.

Returns:

the observable for the sum value

sumFloat

@Nonnull
public ObservableBuilder<java.lang.Float> sumFloat()

Computes and signals the sum of the values of the Float source. The source may not send nulls.

Returns:

the observable for the sum value

sumInt

@Nonnull
public ObservableBuilder<java.lang.Integer> sumInt()

Computes and signals the sum of the values of the Integer source. The source may not send nulls. An empty source produces an empty sum

Returns:

the observable for the sum value

sumIntAsDouble

@Nonnull
public ObservableBuilder<java.lang.Double> sumIntAsDouble()

Computes and signals the sum of the values of the Integer source by using a double intermediate representation. The source may not send nulls. An empty source produces an empty sum

Returns:

the observable for the sum value

sumLong

@Nonnull
public ObservableBuilder<java.lang.Long> sumLong()

Computes and signals the sum of the values of the Long source. The source may not send nulls.

Returns:

the observable for the sum value

sumLongAsDouble

@Nonnull
public ObservableBuilder<java.lang.Double> sumLongAsDouble()

Computes and signals the sum of the values of the Long sourceby using a double intermediate representation. The source may not send nulls.

Returns:

the observable for the sum value

switchToNext

@Nonnull
public ObservableBuilder<T> switchToNext(@Nonnull
                                                   Observable<? extends Observable<? extends T>> sources)

Returns an observer which relays Ts from the source observables in a way, when a new inner observable comes in, the previous one is deregistered and the new one is continued with. Basically, it is an unbounded ys.takeUntil(xs).takeUntil(zs)...

Parameters:

sources - the source of multiple observables of Ts.

Returns:

the new observable

synchronize

@Nonnull
public ObservableBuilder<T> synchronize()

Returns an observable sequence which ensures that the registering observers follow the general contract on observables by serializing access to the event methods. This can be used to make non-conformant observables to work with observers conforming the contract.

Returns:

the new observable

Since:

0.97

take

@Nonnull
public ObservableBuilder<T> take(int count)

Creates an observable which takes the specified number of Ts from the source, unregisters and completes.

Parameters:

count - the number of elements to relay

Returns:

the new observable

take

@Nonnull
public ObservableBuilder<T> take(int count,
                                           @Nonnull
                                           Scheduler scheduler)

Creates an observable which takes the specified number of Ts from the source, unregisters and completes.

Parameters:

count - the number of elements to relay

scheduler - the scheduler to use when emitting a finish if count is zero

Returns:

the new observable

take

@Nonnull
public ObservableBuilder<T> take(long time,
                                           @Nonnull
                                           java.util.concurrent.TimeUnit unit)

Takes the elements from the source sequence until the time runs out.

Parameters:

time - the time

unit - the unit

Returns:

the new observable

Since:

0.97

take

@Nonnull
public ObservableBuilder<T> take(long time,
                                           @Nonnull
                                           java.util.concurrent.TimeUnit unit,
                                           @Nonnull
                                           Scheduler pool)

Takes the elements from the source sequence until the time runs out.

Parameters:

time - the time

unit - the unit

pool - the pool for timed operation

Returns:

the new observable

Since:

0.97

takeLast

@Nonnull
public ObservableBuilder<T> takeLast(int count)

Returns an observable which returns the last count elements from the source observable.

Parameters:

count - the number elements to return

Returns:

the new observable

takeLast

@Nonnull
public ObservableBuilder<T> takeLast(int count,
                                               @Nonnull
                                               Scheduler pool)

Returns an observable which returns the last count elements from the source observable and emits them from the specified scheduler pool.

Parameters:

count - the number elements to return

pool - the scheduler where from emit the last values

Returns:

the new observable

Since:

0.97

takeLast

@Nonnull
public ObservableBuilder<T> takeLast(long time,
                                               @Nonnull
                                               java.util.concurrent.TimeUnit unit)

Skips the elements from the end for the specified amount of time.

These last elements are drained in the caller's thread of the finish event.

Since there is no way to know the total duration of the sequence, the operator queues elements unit they become older than the specified time, causing the elements to be delayed by time.

Parameters:

time - the time

unit - the unit

Returns:

the new observable

Since:

0.97

takeLast

@Nonnull
public ObservableBuilder<T> takeLast(long time,
                                               @Nonnull
                                               java.util.concurrent.TimeUnit unit,
                                               @Nonnull
                                               Scheduler drainPool)

Skips the elements from the end for the specified amount of time.

These last elements are drained in the given scheduler.

Since there is no way to know the total duration of the sequence, the operator queues elements unit they become older than the specified time, causing the elements to be delayed by time.

Parameters:

time - the time

unit - the unit

drainPool - the optional pool to drain the accumulated values, if null, the thread of the finish caller is used.

Returns:

the new observable

Since:

0.97

takeLastBuffer

@Nonnull
public ObservableBuilder<java.util.List<T>> takeLastBuffer(int count)

Returns an observable which returns the last count elements from the source observable and returns it as a single list.

Parameters:

count - the number elements to return

Returns:

the new observable

Since:

0.97

takeLastBuffer

@Nonnull
public ObservableBuilder<java.util.List<T>> takeLastBuffer(long time,
                                                                     @Nonnull
                                                                     java.util.concurrent.TimeUnit unit)

Skips the elements from the end for the specified amount of time as one list.

These last elements are drained in the caller's thread of the finish event.

Since there is no way to know the total duration of the sequence, the operator queues elements unit they become older than the specified time, causing the elements to be delayed by time.

Parameters:

time - the time

unit - the unit

Returns:

the new observable

Since:

0.97

takeLastBuffer

@Nonnull
public ObservableBuilder<java.util.List<T>> takeLastBuffer(long time,
                                                                     @Nonnull
                                                                     java.util.concurrent.TimeUnit unit,
                                                                     @Nonnull
                                                                     Scheduler drainPool)

Skips the elements from the end for the specified amount of time as one list.

These last elements are drained in the given scheduler.

Since there is no way to know the total duration of the sequence, the operator queues elements unit they become older than the specified time, causing the elements to be delayed by time.

Parameters:

time - the time

unit - the unit

drainPool - the optional pool to drain the accumulated values, if null, the thread of the finish caller is used.

Returns:

the new observable

Since:

0.97

takeUntil

@Nonnull
public <U> ObservableBuilder<T> takeUntil(@Nonnull
                                                    Observable<U> signaller)

Creates an observable which takes values from the source until the signaller produces a value. If the signaller never signals, all source elements are relayed.

Type Parameters:

U - the signaller element type, irrelevant

Parameters:

signaller - the source of Us

Returns:

the new observable

takeWhile

@Nonnull
public ObservableBuilder<T> takeWhile(@Nonnull
                                                Func1<? super T,java.lang.Boolean> predicate)

Creates an observable which takes values from source until the predicate returns false for the current element, then skips the remaining values.

Parameters:

predicate - the predicate

Returns:

the new observable

takeWhile

@Nonnull
public ObservableBuilder<T> takeWhile(@Nonnull
                                                Func2<? super T,? super java.lang.Integer,java.lang.Boolean> predicate)

Creates an observable which takes values from source until the indexed predicate returns false for the current element, then skips the remaining values.

Parameters:

predicate - the predicate

Returns:

the new observable

Since:

0.97

takeWhileLong

@Nonnull
public ObservableBuilder<T> takeWhileLong(@Nonnull
                                                    Func2<? super T,? super java.lang.Long,java.lang.Boolean> predicate)

Creates an observable which takes values from source until the long indexed predicate returns false for the current element, then skips the remaining values.

Parameters:

predicate - the predicate

Returns:

the new observable

Since:

0.97

throttle

public <U> ObservableBuilder<T> throttle(@Nonnull
                                         Func1<? super T,? extends Observable<U>> durationSelector)

Fires the last event from the source observable if no events are fired during a selector-returned observable window.

Exception semantics: exceptions from the source and windows are forwarded immediately and the sequence is terminated.

The window close is triggered by either a next or finish event.

Type Parameters:

U - the window observable's type, irrelevant

Parameters:

durationSelector - the duration selector.

Returns:

the new observable

Since:

0.97

throttle

@Nonnull
public ObservableBuilder<T> throttle(long delay,
                                               @Nonnull
                                               java.util.concurrent.TimeUnit unit)

Creates and observable which fires the last value from source when the given timespan elapsed without a new value occurring from the source. It is basically how Content Assistant popup works after the user pauses in its typing. Uses the default scheduler.

Parameters:

delay - how much time should elapse since the last event to actually forward that event

unit - the delay time unit

Returns:

the observable

throttle

@Nonnull
public ObservableBuilder<T> throttle(long delay,
                                               @Nonnull
                                               java.util.concurrent.TimeUnit unit,
                                               @Nonnull
                                               Scheduler pool)

Creates and observable which fires the last value from source when the given timespan elapsed without a new value occurring from the source. It is basically how Content Assistant popup works after the user pauses in its typing.

Parameters:

delay - how much time should elapse since the last event to actually forward that event

unit - the delay time unit

pool - the pool where the delay-watcher should operate

Returns:

the observable

timeout

@Nonnull
public <V> ObservableBuilder<T> timeout(@Nonnull
                                                  Func1<? super T,? extends Observable<V>> timeoutSelector)

Applies a timeout to each element of the sequence or throws a TimeoutException if an element is not followed by another within the firing of the timeout selector's observable sequence.

The first element is waited forever, the timeout observables fire on both next and finish events.

Exception semantics: any exceptions thrown are immediately forwarded and the sequence terminated.

Type Parameters:

V - the per-element timeout type, irrelevant

Parameters:

timeoutSelector - the timeout selector for each value

Returns:

the new observable

Since:

0.97

timeout

@Nonnull
public <V> ObservableBuilder<T> timeout(@Nonnull
                                                  Func1<? super T,? extends Observable<V>> timeoutSelector,
                                                  @Nonnull
                                                  Observable<? extends T> other)

Applies a timeout to each element in the source sequence, for each element a separate window is opened in the form of observable sequence. If any of these window observables fire next or finish, the sequence is switched to the other observable.

The first element is waited forever, the timeout observables fire on both next and finish events.

Exception semantics: any exceptions thrown are immediately forwarded and the sequence terminated.

Type Parameters:

V - the per-element timeout type, irrelevant

Parameters:

timeoutSelector - the timeout selector for each value

other - the outer source to switch to in case of timeout

Returns:

the new observable

Since:

0.97

timeout

@Nonnull
public ObservableBuilder<T> timeout(long time,
                                              @Nonnull
                                              java.util.concurrent.TimeUnit unit)

Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it singlals a java.util.concurrent.TimeoutException.

Parameters:

time - the maximum allowed timespan between events

unit - the time unit

Returns:

the observer.

timeout

@Nonnull
public ObservableBuilder<T> timeout(long time,
                                              @Nonnull
                                              java.util.concurrent.TimeUnit unit,
                                              @Nonnull
                                              Observable<? extends T> other)

Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it switches to the other observable.

Parameters:

time - the maximum allowed timespan between events

unit - the time unit

other - the other observable to continue with in case a timeout occurs

Returns:

the observer.

timeout

@Nonnull
public ObservableBuilder<T> timeout(long time,
                                              @Nonnull
                                              java.util.concurrent.TimeUnit unit,
                                              @Nonnull
                                              Observable<? extends T> other,
                                              @Nonnull
                                              Scheduler pool)

Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it switches to the other observable.

Parameters:

time - the maximum allowed timespan between events

unit - the time unit

other - the other observable to continue with in case a timeout occurs

pool - the scheduler pool for the timeout evaluation

Returns:

the observer.

timeout

@Nonnull
public ObservableBuilder<T> timeout(long time,
                                              @Nonnull
                                              java.util.concurrent.TimeUnit unit,
                                              @Nonnull
                                              Scheduler pool)

Creates an observable which relays events if they arrive from the source observable within the specified amount of time or it singlals a java.util.concurrent.TimeoutException.

Parameters:

time - the maximum allowed timespan between events

unit - the time unit

pool - the scheduler pool for the timeout evaluation

Returns:

the observer.

timeout

@Nonnull
public <U,V> ObservableBuilder<T> timeout(@Nonnull
                                                    Observable<U> firstTimeout,
                                                    @Nonnull
                                                    Func1<? super T,? extends Observable<V>> timeoutSelector)

Applies a timeout to each element of the sequence or throws a TimeoutException if an element is not followed by another within the firing of the timeout selector's observable sequence.

The first element is until the given firstTimeout observable fires. The timeout observables fire on both next and finish events.

Exception semantics: any exceptions thrown are immediately forwarded and the sequence terminated.

Type Parameters:

U - the initial timeout element type, irrelevant

V - the per-element timeout type, irrelevant

Parameters:

firstTimeout - the timeout for the first element, use never() to wait for it indefinitely

timeoutSelector - the timeout selector for each value

Returns:

the new observable

Since:

0.97

timeout

@Nonnull
public <U,V> ObservableBuilder<T> timeout(@Nonnull
                                                    Observable<U> firstTimeout,
                                                    @Nonnull
                                                    Func1<? super T,? extends Observable<V>> timeoutSelector,
                                                    @Nonnull
                                                    Observable<? extends T> other)

Applies a timeout to each element in the source sequence, starting with the timeout from the firsTimeout observabe, then, for each element a separate window is opened in the form of observable sequence. If any of these window observables fire next or finish, the sequence is switched to the other observable.

Type Parameters:

U - the initial timeout element type, irrelevant

V - the per-element timeout type, irrelevant

Parameters:

firstTimeout - the timeout for the first element, use never() to wait for it indefinitely

timeoutSelector - the timeout selector for each value

other - the outer source to switch to in case of timeout

Returns:

the new observable

Since:

0.97

timeoutFinish

@Nonnull
public ObservableBuilder<T> timeoutFinish(long time,
                                                    @Nonnull
                                                    java.util.concurrent.TimeUnit unit)

Creates an observable which finishes its observers after the specified amount of time if no error or finish events appeared till then.

Parameters:

time - the time to wait

unit - the time unit to wait

Returns:

the new observable

Since:

0.97

timeoutFinish

@Nonnull
public ObservableBuilder<T> timeoutFinish(long time,
                                                    @Nonnull
                                                    java.util.concurrent.TimeUnit unit,
                                                    @Nonnull
                                                    Scheduler scheduler)

Creates an observable which finishes its observers after the specified amount of time if no error or finish events appeared till then.

Parameters:

time - the time to wait

unit - the time unit to wait

scheduler - the scheduler used for the wait

Returns:

the new observable

Since:

0.97

toArray

@Nonnull
public ObservableBuilder<java.lang.Object[]> toArray()

Creates an array from the observable sequence elements.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial array is created).

Returns:

the object array

toArray

@Nonnull
public ObservableBuilder<T[]> toArray(@Nonnull
                                                T[] a)

Creates an array from the observable sequence elements by using the given array for the template to create a dynamicly typed array of Ts.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial array is created).

Parameters:

a - the template array, noes not change its value

Returns:

the observable

toIterable

@Nonnull
public IterableBuilder<T> toIterable()

Converts this observable into an iterable builder.

Returns:

the iterable builder

toList

@Nonnull
public ObservableBuilder<java.util.List<T>> toList()

Collect the elements of the source observable into a single list.

Returns:

the new observable

toMap

@Nonnull
public <K> ObservableBuilder<java.util.Map<K,T>> toMap(@Nonnull
                                                                 Func1<? super T,? extends K> keySelector)

Maps the given source of Ts by using the key extractor and returns a single Map of them. The keys are compared against each other by the Object.equals() semantics.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

Parameters:

keySelector - the key selector

Returns:

the new observable

toMap

@Nonnull
public <K,V> ObservableBuilder<java.util.Map<K,V>> toMap(@Nonnull
                                                                   Func1<? super T,? extends K> keySelector,
                                                                   @Nonnull
                                                                   Func1<? super T,? extends V> valueSelector)

Maps the given source of Ts by using the key extractor and returns a single Map of them. The keys are compared against each other by the Object.equals() semantics.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

V - the value type

Parameters:

keySelector - the key selector

valueSelector - the value selector

Returns:

the new observable

toMap

@Nonnull
public <K,V> ObservableBuilder<java.util.Map<K,V>> toMap(@Nonnull
                                                                   Func1<? super T,? extends K> keySelector,
                                                                   @Nonnull
                                                                   Func1<? super T,? extends V> valueSelector,
                                                                   @Nonnull
                                                                   Func2<? super K,? super K,java.lang.Boolean> keyComparer)

Maps the given source of Ts by using the key and value extractor and returns a single Map of them.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

V - the value type

Parameters:

keySelector - the key selector

valueSelector - the value selector

keyComparer - the comparison function for keys

Returns:

the new observable

toMap

@Nonnull
public <K> ObservableBuilder<java.util.Map<K,T>> toMap(@Nonnull
                                                                 Func1<? super T,? extends K> keySelector,
                                                                 @Nonnull
                                                                 Func2<? super K,? super K,java.lang.Boolean> keyComparer)

Maps the given source of Ts by using the key extractor and returns a single Map of them.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

Parameters:

keySelector - the key selector

keyComparer - the key comparer function

Returns:

the new observable

toMultiMap

@Nonnull
public <K> ObservableBuilder<java.util.Map<K,java.util.Collection<T>>> toMultiMap(@Nonnull
                                                                                            Func1<? super T,? extends K> keySelector,
                                                                                            @Nonnull
                                                                                            Func0<? extends java.util.Collection<T>> collectionSupplier)

Maps the given source of Ts by using the key extractor and returns a single multi-map of them. The keys are compared against each other by the Object.equals() semantics.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

Parameters:

keySelector - the key selector

collectionSupplier - the function which retuns a collection to hold the Vs.

Returns:

the new observable

toMultiMap

@Nonnull
public <K> ObservableBuilder<java.util.Map<K,java.util.Collection<T>>> toMultiMap(@Nonnull
                                                                                            Func1<? super T,? extends K> keySelector,
                                                                                            @Nonnull
                                                                                            Func0<? extends java.util.Collection<T>> collectionSupplier,
                                                                                            @Nonnull
                                                                                            Func2<? super K,? super K,java.lang.Boolean> keyComparer)

Maps the given source of Ts by using the key extractor and returns a single multi-map of them.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

Parameters:

keySelector - the key selector

collectionSupplier - the function which retuns a collection to hold the Vs.

keyComparer - the comparison function for keys

Returns:

the new observable

toMultiMap

@Nonnull
public <K,V> ObservableBuilder<java.util.Map<K,java.util.Collection<V>>> toMultiMap(@Nonnull
                                                                                              Func1<? super T,? extends K> keySelector,
                                                                                              @Nonnull
                                                                                              Func0<? extends java.util.Collection<V>> collectionSupplier,
                                                                                              @Nonnull
                                                                                              Func1<? super T,? extends V> valueSelector)

Maps the given source of Ts by using the key and value extractor and returns a single multi-map of them. The keys are compared against each other by the Object.equals() semantics.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

V - the value type

Parameters:

keySelector - the key selector

collectionSupplier - the function which retuns a collection to hold the Vs.

valueSelector - the value selector

Returns:

the new observable

See Also:

Functions#listSupplier(), Functions#setSupplier()

toMultiMap

@Nonnull
public <K,V> ObservableBuilder<java.util.Map<K,java.util.Collection<V>>> toMultiMap(@Nonnull
                                                                                              Func1<? super T,? extends K> keySelector,
                                                                                              @Nonnull
                                                                                              Func0<? extends java.util.Collection<V>> collectionSupplier,
                                                                                              @Nonnull
                                                                                              Func1<? super T,? extends V> valueSelector,
                                                                                              @Nonnull
                                                                                              Func2<? super K,? super K,java.lang.Boolean> keyComparer)

Maps the given source of Ts by using the key and value extractor and returns a single multi-map of them.

Exception semantics: if the source throws an exception, that exception is forwarded (e.g., no partial map is created).

Type Parameters:

K - the key type

V - the value type

Parameters:

keySelector - the key selector

collectionSupplier - the function which retuns a collection to hold the Vs.

valueSelector - the value selector

keyComparer - the comparison function for keys

Returns:

the new observable

toOriginalObservable

@Nonnull
public java.util.Observable toOriginalObservable()

Returns:

Wraps this observable into a java-observable.

unwrap

@Nonnull
public Observable<T> unwrap()

Returns:

Unwraps the underlying Observable in case it is wrapped multiple times with the ObservableBuilder class.

Since:

0.97

where

@Nonnull
public ObservableBuilder<T> where(@Nonnull
                                            Func0<Func2<? super T,? super java.lang.Integer,java.lang.Boolean>> clauseFactory)

Creates a filtered observable where only Ts are relayed which satisfy the clause. The clause receives the index and the current element to test. The clauseFactory is used for each individual registering observer. This can be used to create memorizing filter functions such as distinct.

Parameters:

clauseFactory - the filter clause, the first parameter receives the current index, the second receives the current element

Returns:

the new observable

where

@Nonnull
public ObservableBuilder<T> where(@Nonnull
                                            Func1<? super T,java.lang.Boolean> clause)

Creates a filtered observable where only Ts are relayed which satisfy the clause.

Parameters:

clause - the filter clause

Returns:

the new observable

where

@Nonnull
public ObservableBuilder<T> where(@Nonnull
                                            Func2<? super T,? super java.lang.Integer,java.lang.Boolean> clause)

Creates a filtered observable where only Ts are relayed which satisfy the clause. The clause receives the index and the current element to test.

Parameters:

clause - the filter clause, the first parameter receives the current index, the second receives the current element

Returns:

the new observable

whereLong

@Nonnull
public ObservableBuilder<T> whereLong(@Nonnull
                                                Func2<? super T,? super java.lang.Long,java.lang.Boolean> clause)

Creates a filtered observable where only Ts are relayed which satisfy the clause. The clause receives the index and the current element to test.

Parameters:

clause - the filter clause, the first parameter receives the current index, the second receives the current element

Returns:

the new observable

Since:

0.97

whileDo

@Nonnull
public ObservableBuilder<T> whileDo(@Nonnull
                                              Func0<java.lang.Boolean> condition)

Repeatedly registers with the source observable if the condition holds on registration. The condition is checked before each registration.

Parameters:

condition - the condition to check before each registration

Returns:

the new observable

Since:

0.97

window

@Nonnull
public <U> ObservableBuilder<Observable<T>> window(@Nonnull
                                                             Func0<? extends Observable<U>> windowClosing)

Splits the source stream into separate observables once the windowClosing fires an event.

Type Parameters:

U - the closing event type, irrelevant

Parameters:

windowClosing - the source of the window splitting events

Returns:

the observable on sequences of observables of Ts

window

@Nonnull
public ObservableBuilder<Observable<T>> window(int size)

Project the source sequence to non-overlapping windows with the given size.

Parameters:

size - the window size

Returns:

the observable sequence

window

@Nonnull
public Observable<Observable<T>> window(int size,
                                                  int skip)

Project the source sequence to potentially overlapping windows whose start is determined by skip and lengths by size.

Parameters:

size - the window size

skip - the elements to skip between windows.

Returns:

the observable sequence

Since:

0.97

window

@Nonnull
public ObservableBuilder<Observable<T>> window(int size,
                                                         long timespan,
                                                         @Nonnull
                                                         java.util.concurrent.TimeUnit unit)

Projects each element into a window that is completed by either its full or the specified amount of time elapsed. Time periods are absolute from the beginning of the streaming.

Parameters:

size - the window size

timespan - the window length

unit - the time unit

Returns:

the observable of the windows of Ts

Since:

0.97

window

@Nonnull
public ObservableBuilder<Observable<T>> window(int size,
                                                         long timespan,
                                                         @Nonnull
                                                         java.util.concurrent.TimeUnit unit,
                                                         @Nonnull
                                                         Scheduler pool)

Projects each element into a window that is completed by either its full or the specified amount of time elapsed. Time periods are absolute from the beginning of the streaming.

Parameters:

size - the window size

timespan - the window length

unit - the time unit

pool - the scheduler to run the timed operations

Returns:

the observable of the windows of Ts

Since:

0.97

window

@Nonnull
public ObservableBuilder<Observable<T>> window(long timespan,
                                                         long timeshift,
                                                         @Nonnull
                                                         java.util.concurrent.TimeUnit unit)

Projects elements from the source observable into zero or more windows which are produced based on timing information.

Uses the default scheduler.

Parameters:

timespan - the length of each window

timeshift - the interval between the creation of consequtive windows

unit - the time unit

Returns:

the windowed observable sequence

Since:

0.97

window

@Nonnull
public ObservableBuilder<Observable<T>> window(long timespan,
                                                         long timeshift,
                                                         @Nonnull
                                                         java.util.concurrent.TimeUnit unit,
                                                         @Nonnull
                                                         Scheduler pool)

Projects elements from the source observable into zero or more windows which are produced based on timing information and run on the specified scheduler.

Parameters:

timespan - the length of each window

timeshift - the interval between the creation of consequtive windows

unit - the time unit

pool - the scheduler for the timed operations

Returns:

the windowed observable sequence

Since:

0.97

window

@Nonnull
public ObservableBuilder<Observable<T>> window(long timespan,
                                                         @Nonnull
                                                         java.util.concurrent.TimeUnit unit)

Projects elements from the source observable into distinct windows which are produced based on timing information.

Uses the default scheduler.

Parameters:

timespan - the length of each window

unit - the time unit

Returns:

the windowed observable sequence

Since:

0.97

window

@Nonnull
public ObservableBuilder<Observable<T>> window(long timespan,
                                                         @Nonnull
                                                         java.util.concurrent.TimeUnit unit,
                                                         @Nonnull
                                                         Scheduler pool)

Projects elements from the source observable into zero or more windows which are produced based on timing information and run on the specified scheduler.

Parameters:

timespan - the length of each window

unit - the time unit

pool - the scheduler for the timed operations

Returns:

the windowed observable sequence

Since:

0.97

window

@Nonnull
public <U,V> ObservableBuilder<Observable<T>> window(@Nonnull
                                                               Observable<? extends U> windowOpening,
                                                               @Nonnull
                                                               Func1<? super U,? extends Observable<V>> windowClosing)

Splits the source stream into separate observables by starting at windowOpening events and closing at windowClosing events.

Type Parameters:

U - the opening event type, irrelevant

V - the closing event type, irrelevant

Parameters:

windowOpening - te source of the window opening events

windowClosing - the source of the window splitting events

Returns:

the observable on sequences of observables of Ts

window

public <U> Observable<Observable<T>> window(@Nonnull
                                            Observable<U> boundary)

Projects the source elements into a non-overlapping consecutive windows.

The first window opens immediately, The current window is closed when the boundary observable sequence has sent a value. The finish of the boundary will finish both inner and outer observables.

Exception semantics: exception thrown by the source or the windowClosingSelector's observable is propagated to both the outer and inner observable returned.

Type Parameters:

U - the window boundary element type (irrelevant

Parameters:

boundary - the window boundary indicator.

Returns:

the new observable

zip

@Nonnull
public <U,V> ObservableBuilder<V> zip(@Nonnull
                                                java.lang.Iterable<? extends U> right,
                                                @Nonnull
                                                Func2<? super T,? super U,? extends V> selector)

Creates an observable which waits for events from left and combines it with the next available value from the right iterable, applies the selector function and emits the resulting T. The error() and finish() signals are relayed to the output. The result is finished if the right iterator runs out of values before the left iterator.

Type Parameters:

U - the value type streamed on the left observable

V - the value type streamed on the right iterable

Parameters:

right - the right iterable of Vs

selector - the selector taking the left Us and right Vs.

Returns:

the resulting observable

zip

@Nonnull
public <U,V> ObservableBuilder<V> zip(@Nonnull
                                                Observable<? extends U> right,
                                                @Nonnull
                                                Func2<T,U,V> selector)

Creates an observable which waits for events from left and combines it with the next available value from the right observable, applies the selector function and emits the resulting T. Basically it emmits a T when both an U and V is available. The output stream throws error or terminates if any of the streams throws or terminates.

Type Parameters:

U - the value type streamed on the right iterable

V - the result type

Parameters:

right - the right iterable of Vs

selector - the selector taking the left Us and right Vs.

Returns:

the resulting observable

zipFirst

@Nonnull
public ObservableBuilder<java.util.List<T>> zipFirst(T constant)

Combine a stream of Ts with a constant T whenever the src fires. The observed list contains the values of src as the first value, constant as the second.

Parameters:

constant - the constant T to combine with

Returns:

the new observer

zipLast

@Nonnull
public ObservableBuilder<java.util.List<T>> zipLast(@Nonnull
                                                              java.util.List<? extends Observable<? extends T>> srcs)

Combine the incoming Ts of the various observables into a single list of Ts like using Reactive.zip() on more than two sources.

Parameters:

srcs - the iterable of observable sources.

Returns:

the new observable

zipLast

@Nonnull
public ObservableBuilder<java.util.List<T>> zipLast(T constant)

Combine a constant T with a stream of Ts whenever the src fires. The observed sequence contains the constant as first, the src value as second.

Parameters:

constant - the constant T to combine with

Returns:

the new observer