Package hu.akarnokd.reactive4java.reactive

This package contains the Reactive main utility class for the reactive programming side of the library, accompanied by some helper classes.

See: Description

Class Summary

Class	Description
AddTimeInterval<T>	Returns an observable which provides a TimeInterval of Ts which records the elapsed time between successive elements.
Aggregate	Container class for aggregate operators.
Aggregate.Projected<V,T,U>	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.
Aggregate.Scan<T>	Creates an observable which accumultates the given source and submits each intermediate results to its subscribers.
Aggregate.ScanSeeded<U,T>	Creates an observable which accumultates the given source and submits each intermediate results to its subscribers.
Aggregate.Seeded<U,T>	Apply an accumulator function over the observable source and submit the accumulated value to the returned observable.
Aggregate.SeededIndexedProjected<V,T,U>	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.
Aggregate.Simple<T>	Apply an accumulator function over the observable source and submit the accumulated value to the returned observable at each incoming value.
Ambiguous<T>	Channels the values of the first observable who fires first from the given set of observables.
Buffer	Buffering related observable implementations.
Buffer.WithBoundary<T,U>	Buffers the source elements into non-overlapping lists separated by notification values from the boundary observable and its finish event.
Buffer.WithClosing<T,U>	Buffer parts of the source until the window observable finishes.
Buffer.WithOpenClose<T,U,V>	Projects the incoming values into multiple buffers based on when a window-open fires an event and a window-close finishes.
Buffer.WithSizeOrTime<T>	Buffer the Ts of the source until the buffer reaches its capacity or the current time unit runs out.
Buffer.WithSizeSkip<T>	Project the source sequence to potentially overlapping buffers whose start is determined by skip and lengths by size.
Buffer.WithTime<T>	Buffers the source observable Ts into a list of Ts periodically and submits them to the returned observable.
Collect<U,T>	Produces an iterable sequence that returns elements collected/aggregated/whatever from the source sequence between consequtive iteration.
CombineLatest	Helper class for the combineLatest operator implementations.
CombineLatest.NullStart<T,U,V>	Returns an observable which combines the latest values of both streams whenever one sends a new value, but only after both sent a value.
CombineLatest.Sent<V,T,U>	Returns an observable which combines the latest values of both streams whenever one sends a new value.
Concat	Contains implementation classes for concatenating various sources.
Concat.FromIterable	Iterable main source.
Concat.FromIterable.IndexedSelector<T,U>	Concatenates the observable sequences resulting from enumerating the sorce iterable and calling the indexed resultSelector function.
Concat.FromIterable.Selector<T,U>	Concatenates the observable sequences resulting from enumerating the sorce iterable and calling the resultSelector function.
Concat.FromObservable	Observable main source.
Concat.FromObservable.IndexedSelector<T,U>	Concatenate the the multiple sources selected by the indexed function after another.
Concat.FromObservable.Selector<T,U>	Concatenate the the multiple sources selected by the function after another.
Containment	Helper class for containment testing operators.
Containment.All<T>	Signals a single true or false if all elements of the observable match the predicate.
Containment.Any<T>	Signals a single true if the source observable contains any element.
Count	Helper class for Reactive.count operators.
Count.AsInt<T>	Counts the number of elements in the observable source as an int.
Count.AsLong<T>	Counts the number of elements in the observable source as long.
Delay	Helper class for Reactive.delay operators.
Delay.ByObservable<T,U,V>	Delays the observable sequence based on the subscription delay and per element delay provided by a function.
Delay.ByTime<T>	Delays the propagation of events of the source by the given amount.
Delay.DelayedObservation<T>	Base class for the delayed observation delivery.
Delay.OnError<T>	Deliver an error() event.
Delay.OnFinish<T>	Deliver a finish() event.
Delay.OnNext<T>	Deliver a next() value.
Delay.Registration<T>	Delays the registration to the underlying observable by a given amount.
Distinct<T,U>	Returns distinctly keyed elements from the source.
GroupBy<Key,U,T>	Group the specified source according to the keys provided by the extractor function and compute key equality by the comparer function.
GroupByUntil	Helper class for Reactive.groupByUntil operators.
GroupByUntil.Default<K,V,T,D>	Groups the source sequence of Ts until the specified duration for that group fires.
GroupByUntil.WithComparer<K,V,T,D>	Groups the source sequence of Ts until the specified duration for that group fires.
GroupJoin<Result,Left,Right,LeftDuration,RightDuration>	Returns an observable which correlates two streams of values based on their time when they overlapped and groups the results.
Invoke	Helper class for invoking actions during an stream of observable sequence.
Invoke.OnNext<T>	Executes an action on the received element in the next() call while relaying events.
Invoke.OnNextError<T>	Invokes an action on the next and error methods while relaying events.
Invoke.OnNextErrorFinish<T>	Invoke an action on the next, error and finish methods while relaying events.
Invoke.OnNextFinish<T>	Invoke an action on the next and finish methods while relaying events.
Invoke.OnObserver<T>	Invoke the methods of the given observer while relaying events.
Join<Left,Right,LeftDuration,RightDuration,Result>	Correlates elements of two sequences based on overlapping durations.
Latest<T>	Returns an iterable sequence which returns the latest element from the observable sequence, consuming it only once.
MostRecent<T>	Samples the latest T value coming from the source observable or the initial value when no messages arrived so far.
Next<T>	Returns an iterable sequence which blocks until an element becomes available from the source.
Range	Helper class for Reactive.range operators.
Range.AsBigDecimal	Generates a range of values.
Range.AsBigInteger	Generates a range of values.
Range.AsDouble	Generates a range of values.
Range.AsFloat	Generates a range of values.
Range.AsInt	Generates a range of values.
Range.AsLong	Generates a range of values.
Reactive	Utility class with operators and helper methods for reactive programming with Observables and Observers.
RefCount<T>	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.
Repeat	Contains repeat-like observable sequence implementations.
Repeat.DoWhile<T>	Repeats the given source so long as the condition returns true.
Repeat.RepeatValue<T>	Creates an observable which repeatedly calls the given function which generates the Ts indefinitely.
Repeat.WhileDo<T>	Repeatedly registers with the source observable if the condition holds on registration.
Resume	Helper class for the Reactive.resumeXYZ operators.
Resume.Always<T>	Returns an observable which listens to elements from a source until it signals an error() or finish() and continues with the next observable.
Resume.Conditionally<T>	Continues the observable sequence in case of exception whith the sequence provided by the function for that particular exception.
Resume.OnError<T>	It tries to submit the values of first observable, but when it throws an exeption, the next observable within source is used further on.
Resume.Retry<T>	Restarts the observation until the source observable terminates normally.
Resume.RetryCount<T>	Restarts the observation until the source observable terminates normally or the count retry count was used up.
Sample	Helper class for Reactive.sample operations.
Sample.ByObservable<T,U>	Samples the observable sequence when the other sequence fires an event.
Sample.ByTime<T>	Samples the source observable by the given time interval.
Select	Helper class of select and few similar operators.
Select.Cast<T>	Casts the values of the source sequence into the target type.
Select.CastToken<T>	Casts the values of the source sequence into the given type via the type token.
Select.DefaultIfEmptyFunc<T>	Returns a single value produced by a function in case the source observable is empty.
Select.Indexed<T,U>	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.
Select.LongIndexed<T,U>	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.
Select.Simple<T,U>	Use the mapper to transform the T source into an U source.
SelectMany	Helper class for Reactive.selectMany operators.
SelectMany.Paired<T,U,V>	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.
SelectMany.WithIterable<T,U,V>	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.
Skip	Helper class for skip-like operators.
Skip.First<T>	Skips the given amount of next() messages from source and relays the rest.
Skip.FirstTimed<T>	Skips elements of the source observable for the specified amount of time.
Skip.Last<T>	Skips the last count elements from the source observable.
Skip.LastTimed<T>	Skips the elements from the end for the specified amount of time.
Skip.Until<T,U>	Skip the source elements until the signaller sends its first element.
Skip.While<T>	Skips the Ts from source while the specified condition returns true.
Skip.WhileIndexed<T>	Skips the Ts from source while the specified indexed condition returns true.
Skip.WhileLongIndexed<T>	Skips the Ts from source while the specified long indexed condition returns true.
Take	Helper class for take like operators.
Take.First<T>	Creates an observable which takes the specified number of Ts from the source, unregisters and completes.
Take.FirstTimed<T>	Takes the elements from the source sequence until the time runs out.
Take.Last<T>	Returns an observable which returns the last count elements from the source observable.
Take.LastBuffer<T>	Returns an observable which returns the last count elements from the source observable and returns it as a single list.
Take.LastBufferTimed<T>	Returns elements from the end of the sequence during the specified time interval in one list.
Take.LastScheduled<T>	Returns an observable which returns the last count elements from the source observable and emits them from the specified scheduler pool.
Take.LastTimed<T>	Returns elements from the end of the sequence during the specified time interval.
Take.Until<T,U>	Creates an observable which takes values from the source until the signaller produces a value.
Take.While<T>	Creates an observable which takes values from source until the predicate returns false for the current element, then skips the remaining values.
Take.WhileIndexed<T>	Creates an observable which takes values from source until the indexed predicate returns false for the current element, then skips the remaining values.
Take.WhileLongIndexed<T>	Creates an observable which takes values from source until the indexed predicate returns false for the current element, then skips the remaining values.
Throttle	Helper class for Reactive.throttle operators.
Throttle.ByObservable<T,U>	Fires the last event from the source observable if no events are fired during a selector-returned observable window.
Throttle.ByTime<T>	Creates and observable which fires the last value from source when the given timespan elapsed without a new value occurring from the source.
Timeout	Helper class for Reactive.timeout operations.
Timeout.ByObservables<T,U,V>	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.
Timeout.Switch<T>	Applies a timeout for each element in the source sequence.
ToIterable<T>	Convert the given observable instance into a classical iterable instance.
ToPrimitive	Helper class for object-to-primitive conversion observables.
ToPrimitive.ToDouble	Converts an object-double to primitive-double observable sequence.
ToPrimitive.ToInt	Converts an object-int to primitive-int observable sequence.
ToPrimitive.ToLong	Converts an object-long to primitive-long observable sequence.
Where	Helper class for where like operations.
Where.Indexed<T>	Creates a filtered observable where only Ts are relayed which satisfy the clause.
Where.IndexedFactory<T>	Creates a filtered observable where only Ts are relayed which satisfy the clause.
Where.LongIndexed<T>	Creates a filtered observable where only Ts are relayed which satisfy the clause.
Where.OfType<T>	Filters the elements of the source sequence which is assignable to the provided type.
Where.Simple<T>	Creates a filtered observable where only Ts are relayed which satisfy the clause.
Windowing	Helper class for the Reactive.window operators.
Windowing.WithBoundary<T,U>	Projects the source elements into a non-overlapping consecutive windows.
Windowing.WithClosing<T,U>	Projects the parts of the source into non-overlapping observable sequences until the window observable finishes.
Windowing.WithOpenClose<T,U,V>	Projects the source elements into multiple, potentially overlapping windows.
Windowing.WithSizeSkip<T>	Project the source sequence to potentially overlapping windows whose start is determined by skip and lengths by size.
Windowing.WithTime<T>	Projects elements from the source observable into zero or more windows which are produced based on timing information.
Windowing.WithTimeOrSize<T>	Projects each element into a window that is completed by either its full or the specified amount of time elapsed.
Zip	Helper class for zip operators.
Zip.ManyObservables<T,U>	Merges the values across multiple sources and applies the selector function.
Zip.ManyObservables.ItemObserver<T>	The individual line's observer.
Zip.ObservableAndIterable<T,U,V>	Pairwise merges the iterable and observable source sequences and applies a selector function to produce the final observable values.
Zip.TwoObservable<T,U,V>	Pairwise merges the two observable sequences and emits the value by the selector.

Enum Summary

Enum	Description
Reactive.ObserverState	The diagnostic states of the current runnable.

Package hu.akarnokd.reactive4java.reactive Description

This package contains the Reactive main utility class for the reactive programming side of the library, accompanied by some helper classes.