Package | Description |
---|---|
rx |
Base reactive classes: Observable, Single and Completable; base reactive consumers;
other common base interfaces.
|
rx.functions |
Functional interfaces of functions and actions of arity 0 to 9 and related
utility classes.
|
rx.internal.operators |
Operators that allow composing Observables to transform and
manipulate data in an asynchronous, functional and thread-safe manner.
|
rx.observables |
Classes extending the Observable base reactive class, synchronous and
asynchronous event generators.
|
Modifier and Type | Interface and Description |
---|---|
static interface |
Completable.OnSubscribe
Callback used for building deferred computations that takes a CompletableSubscriber.
|
static interface |
Completable.Operator
Convenience interface and callback used by the lift operator that given a child CompletableSubscriber,
return a parent CompletableSubscriber that does any kind of lifecycle-related transformations.
|
static interface |
Completable.Transformer
Convenience interface and callback used by the compose operator to turn a Completable into another
Completable fluently.
|
static interface |
Observable.OnSubscribe<T>
Invoked when Observable.subscribe is called.
|
static interface |
Observable.Operator<R,T>
Operator function for lifting into an Observable.
|
static interface |
Observable.Transformer<T,R>
Function that receives the current Observable and should return another
Observable, possibly with given element type, in exchange that will be
subscribed to by the downstream operators and subscribers.
|
static interface |
Single.OnSubscribe<T>
Invoked when Single.execute is called.
|
static interface |
Single.Transformer<T,R>
Convenience type that allows a function to fluently transform a
Single into another Single via
Single.compose(rx.Single.Transformer<? super T, ? extends R>) . |
Modifier and Type | Interface and Description |
---|---|
interface |
Action
All Action interfaces extend from this.
|
interface |
Action0
A zero-argument action.
|
interface |
Action1<T>
A one-argument action.
|
interface |
Action2<T1,T2>
A two-argument action.
|
interface |
Action3<T1,T2,T3>
A three-argument action.
|
interface |
Action4<T1,T2,T3,T4>
A four-argument action.
|
interface |
Action5<T1,T2,T3,T4,T5>
A five-argument action.
|
interface |
Action6<T1,T2,T3,T4,T5,T6>
A six-argument action.
|
interface |
Action7<T1,T2,T3,T4,T5,T6,T7>
A seven-argument action.
|
interface |
Action8<T1,T2,T3,T4,T5,T6,T7,T8>
An eight-argument action.
|
interface |
Action9<T1,T2,T3,T4,T5,T6,T7,T8,T9>
A nine-argument action.
|
interface |
ActionN
A vector-argument action.
|
interface |
Func0<R>
Represents a function with zero arguments.
|
interface |
Func1<T,R>
Represents a function with one argument.
|
interface |
Func2<T1,T2,R>
Represents a function with two arguments.
|
interface |
Func3<T1,T2,T3,R>
Represents a function with three arguments.
|
interface |
Func4<T1,T2,T3,T4,R>
Represents a function with four arguments.
|
interface |
Func5<T1,T2,T3,T4,T5,R>
Represents a function with five arguments.
|
interface |
Func6<T1,T2,T3,T4,T5,T6,R>
Represents a function with six arguments.
|
interface |
Func7<T1,T2,T3,T4,T5,T6,T7,R>
Represents a function with seven arguments.
|
interface |
Func8<T1,T2,T3,T4,T5,T6,T7,T8,R>
Represents a function with eight arguments.
|
interface |
Func9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R>
Represents a function with nine arguments.
|
interface |
FuncN<R>
Represents a vector-argument function.
|
Modifier and Type | Class and Description |
---|---|
class |
CompletableFlatMapSingleToCompletable<T> |
class |
CompletableFromEmitter
Allows push-based emission of terminal events to a CompletableSubscriber.
|
class |
CompletableOnSubscribeConcat |
class |
CompletableOnSubscribeConcatArray |
class |
CompletableOnSubscribeConcatIterable |
class |
CompletableOnSubscribeMerge |
class |
CompletableOnSubscribeMergeArray |
class |
CompletableOnSubscribeMergeDelayErrorArray |
class |
CompletableOnSubscribeMergeDelayErrorIterable |
class |
CompletableOnSubscribeMergeIterable |
class |
CompletableOnSubscribeTimeout |
class |
EmptyObservableHolder
Holds a singleton instance of an empty Observable which is stateless and completes
the child subscriber immediately.
|
class |
NeverObservableHolder
Holds a singleton instance of a never Observable which is stateless doesn't
call any of the Subscriber's methods.
|
class |
OnSubscribeAmb<T>
Given multiple
Observable s, propagates the one that first emits an item. |
class |
OnSubscribeAutoConnect<T>
Wraps a ConnectableObservable and calls its connect() method once
the specified number of Subscribers have subscribed.
|
class |
OnSubscribeCollect<T,R> |
class |
OnSubscribeCombineLatest<T,R> |
class |
OnSubscribeConcatMap<T,R>
Maps a source sequence into Observables and concatenates them in order, subscribing
to one at a time.
|
class |
OnSubscribeCreate<T> |
class |
OnSubscribeDefer<T>
Do not create the Observable until an Observer subscribes; create a fresh Observable on each
subscription.
|
class |
OnSubscribeDelaySubscription<T>
Delays the subscription to the source by the given amount, running on the given scheduler.
|
class |
OnSubscribeDelaySubscriptionOther<T,U>
Delays the subscription to the main source until the other
observable fires an event or completes.
|
class |
OnSubscribeDelaySubscriptionWithSelector<T,U>
Delays the subscription until the Observable emits an event.
|
class |
OnSubscribeDetach<T>
Nulls out references to upstream data structures when the source terminates or
the child unsubscribes.
|
class |
OnSubscribeDoOnEach<T>
Calls specified actions for each notification.
|
class |
OnSubscribeFilter<T>
Filters an Observable by discarding any items it emits that do not meet some test.
|
class |
OnSubscribeFlatMapCompletable<T>
Maps upstream values to Completables and merges them, up to a given
number of them concurrently, optionally delaying errors.
|
class |
OnSubscribeFlatMapSingle<T,R>
Maps upstream values to Singles and merges them, up to a given
number of them concurrently, optionally delaying errors.
|
class |
OnSubscribeFlattenIterable<T,R>
Flattens a sequence if Iterable sources, generated via a function, into a single sequence.
|
class |
OnSubscribeFromArray<T> |
class |
OnSubscribeFromCallable<T>
Do not invoke the function until an Observer subscribes; Invokes function on each
subscription.
|
class |
OnSubscribeFromIterable<T>
Converts an
Iterable sequence into an Observable . |
class |
OnSubscribeGroupJoin<T1,T2,D1,D2,R>
Correlates two sequences when they overlap and groups the results.
|
class |
OnSubscribeJoin<TLeft,TRight,TLeftDuration,TRightDuration,R>
Correlates the elements of two sequences based on overlapping durations.
|
class |
OnSubscribeLift<T,R>
Transforms the downstream Subscriber into a Subscriber via an operator
callback and calls the parent OnSubscribe.call() method with it.
|
class |
OnSubscribeMap<T,R>
Applies a function of your choosing to every item emitted by an
Observable , and emits the results of
this transformation as a new Observable . |
class |
OnSubscribeOnAssembly<T>
Captures the current stack when it is instantiated, makes
it available through a field and attaches it to all
passing exception.
|
class |
OnSubscribeOnAssemblyCompletable<T>
Captures the current stack when it is instantiated, makes
it available through a field and attaches it to all
passing exception.
|
class |
OnSubscribeOnAssemblySingle<T>
Captures the current stack when it is instantiated, makes
it available through a field and attaches it to all
passing exception.
|
class |
OnSubscribePublishMulticast<T>
Multicasts notifications coming through its input Subscriber view to its
client Subscribers via lockstep backpressure mode.
|
class |
OnSubscribeRange
Emit integers from start to end inclusive.
|
class |
OnSubscribeRedo<T> |
static class |
OnSubscribeRedo.RedoFinite |
static class |
OnSubscribeRedo.RetryWithPredicate |
class |
OnSubscribeReduce<T> |
class |
OnSubscribeReduceSeed<T,R> |
class |
OnSubscribeRefCount<T>
Returns an observable sequence that stays connected to the source as long as
there is at least one subscription to the observable sequence.
|
class |
OnSubscribeSingle<T>
Allows conversion of an Observable to a Single ensuring that exactly one item is emitted - no more and no less.
|
class |
OnSubscribeSkipTimed<T>
Skips elements until a specified time elapses.
|
class |
OnSubscribeSwitchIfEmpty<T>
If the Observable completes without emitting any items, subscribe to an alternate Observable.
|
class |
OnSubscribeTakeLastOne<T> |
class |
OnSubscribeThrow<T>
|
class |
OnSubscribeTimerOnce
Timer that emits a single 0L and completes after the specified time.
|
class |
OnSubscribeTimerPeriodically
Emit 0L after the initial period and ever increasing number after each period.
|
class |
OnSubscribeToMap<T,K,V>
Maps the elements of the source observable into a java.util.Map instance and
emits that once the source observable completes.
|
class |
OnSubscribeToMultimap<T,K,V>
Maps the elements of the source observable into a multimap
(Map<K, Collection<V>>) where each
key entry has a collection of the source's values.
|
class |
OnSubscribeUsing<T,Resource>
Constructs an observable sequence that depends on a resource object.
|
class |
OperatorAll<T>
Returns an Observable that emits a Boolean that indicates whether all items emitted by an
Observable satisfy a condition.
|
class |
OperatorAny<T>
Returns an
Observable that emits true if any element of
an observable sequence satisfies a condition, otherwise false . |
class |
OperatorAsObservable<T>
Hides the identity of another observable.
|
class |
OperatorBufferWithSingleObservable<T,TClosing>
This operation takes
values from the specified
Observable source and stores them in a buffer until the
Observable constructed using the Func0 argument, produces a value. |
class |
OperatorBufferWithSize<T>
This operation takes
values from the specified
Observable source and stores them in all active chunks until the buffer
contains a specified number of elements. |
class |
OperatorBufferWithStartEndObservable<T,TOpening,TClosing>
This operation takes
values from the specified
Observable source and stores them in the currently active chunks. |
class |
OperatorBufferWithTime<T>
This operation takes
values from the specified
Observable source and stores them in a buffer. |
class |
OperatorCast<T,R>
Converts the elements of an observable sequence to the specified type.
|
class |
OperatorDebounceWithSelector<T,U>
Delay the emission via another observable if no new source appears in the meantime.
|
class |
OperatorDebounceWithTime<T>
This operation filters out events which are published too quickly in succession.
|
class |
OperatorDelay<T>
Delays the emission of onNext events by a given amount of time.
|
class |
OperatorDelayWithSelector<T,V>
Delay the subscription and emission of the source items by a per-item observable that fires its first element.
|
class |
OperatorDematerialize<T>
Reverses the effect of
OperatorMaterialize by transforming the Notification objects
emitted by a source Observable into the items or notifications they represent. |
class |
OperatorDistinct<T,U>
Returns an Observable that emits all distinct items emitted by the source.
|
class |
OperatorDistinctUntilChanged<T,U>
Returns an Observable that emits all sequentially distinct items emitted by the source.
|
class |
OperatorDoAfterTerminate<T>
Registers an action to be called after an Observable invokes
onComplete or onError . |
class |
OperatorDoOnRequest<T>
This operator modifies an
Observable so a given action is invoked when the
Producer receives a request. |
class |
OperatorDoOnSubscribe<T>
This operator modifies an
Observable so a given action is invoked when the Observable is subscribed. |
class |
OperatorDoOnUnsubscribe<T>
This operator modifies an
Observable so a given action is invoked when the Observable is unsubscribed. |
class |
OperatorEagerConcatMap<T,R> |
class |
OperatorElementAt<T>
Returns the element at a specified index in a sequence.
|
class |
OperatorGroupBy<T,K,V>
Groups the items emitted by an Observable according to a specified criterion, and emits these
grouped items as Observables, one Observable per group.
|
class |
OperatorIgnoreElements<T> |
class |
OperatorMapNotification<T,R>
Applies a function of your choosing to every item emitted by an
Observable , and emits the results of
this transformation as a new Observable . |
class |
OperatorMapPair<T,U,R>
An
Observable.Operator that pairs up items emitted by a source Observable with the sequence of items
emitted by the Observable that is derived from each item by means of a selector, and emits the
results of this pairing. |
class |
OperatorMaterialize<T>
Turns all of the notifications from an Observable into
onNext emissions, and marks
them with their original notification types within Notification objects. |
class |
OperatorMerge<T>
Flattens a list of
Observable s into one Observable , without any transformation. |
class |
OperatorObserveOn<T>
Delivers events on the specified
Scheduler asynchronously via an unbounded buffer. |
class |
OperatorOnBackpressureBuffer<T> |
class |
OperatorOnBackpressureDrop<T> |
class |
OperatorOnBackpressureLatest<T>
An operator which drops all but the last received value in case the downstream
doesn't request more.
|
class |
OperatorOnErrorResumeNextViaFunction<T>
Instruct an Observable to pass control to another Observable (the return value of a function)
rather than invoking
onError if it encounters an error. |
class |
OperatorRetryWithPredicate<T> |
class |
OperatorSampleWithObservable<T,U>
Sample with the help of another observable.
|
class |
OperatorSampleWithTime<T>
Returns an Observable that emits the results of sampling the items emitted by the source
Observable at a specified time interval.
|
class |
OperatorScan<R,T>
Returns an Observable that applies a function to the first item emitted by a source Observable, then feeds
the result of that function along with the second item emitted by an Observable into the same function, and
so on until all items have been emitted by the source Observable, emitting the result of each of these
iterations.
|
class |
OperatorSerialize<T> |
class |
OperatorSingle<T>
If the Observable completes after emitting a single item that matches a
predicate, return an Observable containing that item.
|
class |
OperatorSkip<T>
Returns an Observable that skips the first
num items emitted by the source
Observable. |
class |
OperatorSkipLast<T>
Bypasses a specified number of elements at the end of an observable sequence.
|
class |
OperatorSkipLastTimed<T>
Skip delivering values in the time window before the values.
|
class |
OperatorSkipUntil<T,U>
Skip elements from the source Observable until the secondary
observable fires an element.
|
class |
OperatorSkipWhile<T>
Skips any emitted source items as long as the specified condition holds true.
|
class |
OperatorSubscribeOn<T>
Subscribes Observers on the specified
Scheduler . |
class |
OperatorSwitch<T>
Transforms an Observable that emits Observables into a single Observable that
emits the items emitted by the most recently published of those Observables.
|
class |
OperatorTake<T>
An
Observable that emits the first num items emitted by the source Observable . |
class |
OperatorTakeLast<T>
Returns an Observable that emits the at most the last
count items emitted by the source Observable. |
class |
OperatorTakeLastTimed<T>
Returns an Observable that emits the last
count items emitted by the source Observable. |
class |
OperatorTakeTimed<T>
Takes values from the source until the specific time elapses.
|
class |
OperatorTakeUntil<T,E>
Returns an Observable that emits the items from the source Observable until another Observable
emits an item.
|
class |
OperatorTakeUntilPredicate<T>
Returns an Observable that emits items emitted by the source Observable until
the provided predicate returns false
|
class |
OperatorTakeWhile<T>
O
Returns an Observable that emits items emitted by the source Observable as long as a specified
condition is true.
|
class |
OperatorThrottleFirst<T>
Throttle by windowing a stream and returning the first value in each window.
|
class |
OperatorTimeInterval<T>
Records the time interval between consecutive elements in an observable sequence.
|
class |
OperatorTimeout<T>
Applies a timeout policy for each element in the observable sequence, using
the specified scheduler to run timeout timers.
|
class |
OperatorTimeoutWithSelector<T,U,V>
Returns an Observable that mirrors the source Observable.
|
class |
OperatorTimestamp<T>
Wraps each item emitted by a source
Observable in a Timestamped object. |
class |
OperatorToObservableList<T>
Returns an
Observable that emits a single item, a list composed of all the items emitted by the
source Observable . |
class |
OperatorToObservableSortedList<T>
Return an
Observable that emits the items emitted by the source Observable , in a sorted order
(each item emitted by the Observable must implement Comparable with respect to all other
items in the sequence, or you must pass in a sort function). |
class |
OperatorUnsubscribeOn<T>
Unsubscribes on the specified Scheduler.
|
class |
OperatorWindowWithObservable<T,U>
Creates non-overlapping windows of items where each window is terminated by
an event from a secondary observable and a new window is started immediately.
|
class |
OperatorWindowWithObservableFactory<T,U>
Creates non-overlapping windows of items where each window is terminated by
an event from a secondary observable and a new window is started immediately.
|
class |
OperatorWindowWithSize<T>
Creates windows of values into the source sequence with skip frequency and size bounds.
|
class |
OperatorWindowWithStartEndObservable<T,U,V>
Creates potentially overlapping windows of the source items where each window is
started by a value emitted by an observable and closed when an associated Observable emits
a value or completes.
|
class |
OperatorWindowWithTime<T>
Creates windows of values into the source sequence with timed window creation, length and size bounds.
|
class |
OperatorWithLatestFrom<T,U,R>
Combines values from two sources only when the main source emits.
|
class |
OperatorWithLatestFromMany<T,R> |
class |
OperatorZip<R>
Returns an Observable that emits the results of a function applied to sets of items emitted, in
sequence, by two or more other Observables.
|
class |
OperatorZipIterable<T1,T2,R> |
class |
SingleDelay<T>
Signal the success or error value on the Scheduler's thread.
|
class |
SingleDoAfterTerminate<T>
Execute an action after onSuccess or onError has been delivered.
|
class |
SingleDoOnEvent<T> |
class |
SingleDoOnSubscribe<T>
Call an Action0 when the subscription happens to the source.
|
class |
SingleDoOnUnsubscribe<T>
Call an Action0 when the subscription happens to the source.
|
class |
SingleFromCallable<T>
Execute a callable and emit its resulting value.
|
class |
SingleFromEmitter<T>
Calls an action with a SingleEmitter instance for each individual subscribers that
generates a terminal signal (eventually).
|
class |
SingleFromFuture<T>
Wait and emit the value of the Future.
|
class |
SingleFromObservable<T>
Wrap an Observable.OnSubscribe and expose it as a Single.OnSubscribe.
|
class |
SingleLiftObservableOperator<T,R>
Lift an Observable.Operator into the Single sequence.
|
class |
SingleObserveOn<T>
Signal the success or error value on the Scheduler's thread.
|
class |
SingleOnErrorReturn<T>
Signal a value returned by a resumeFunction when the source signals a Throwable.
|
class |
SingleOnSubscribeDelaySubscriptionOther<T>
Delays the subscription to the Single until the Observable
fires an event or completes.
|
class |
SingleOnSubscribeMap<T,R>
Applies a function of your choosing to every item emitted by an
Single , and emits the results of
this transformation as a new Single . |
class |
SingleOnSubscribeUsing<T,Resource>
Generates a resource, derives a Single from it and disposes that resource once the
Single terminates.
|
class |
SingleOperatorOnErrorResumeNext<T> |
class |
SingleTakeUntilCompletable<T>
Relay the source signals if the other doesn't terminate before.
|
class |
SingleTakeUntilObservable<T,U>
Relay the source signals if the other doesn't terminate before.
|
class |
SingleTakeUntilSingle<T,U>
Relay the source signals if the other doesn't terminate before.
|
class |
SingleTimeout<T> |
class |
SingleToObservable<T>
Expose a Single.OnSubscribe as an Observable.OnSubscribe.
|
Modifier and Type | Class and Description |
---|---|
class |
AsyncOnSubscribe<S,T>
A utility class to create
OnSubscribe<T> functions that respond correctly to back
pressure requests from subscribers. |
class |
SyncOnSubscribe<S,T>
A utility class to create
OnSubscribe<T> functions that responds correctly to back
pressure requests from subscribers. |
Copyright © 2017. All rights reserved.