| Package | Description |
|---|---|
| rx |
Rx Observables
|
| rx.internal.operators |
Operators that allow composing Observables to transform and manipulate data in an asynchronous, functional and thread-safe manner.
|
| rx.internal.util | |
| rx.observers | |
| rx.subjects |
| Modifier and Type | Class and Description |
|---|---|
class |
Subscriber<T>
Provides a mechanism for receiving push-based notifications from Observables, and permits manual unsubscribing from these Observables.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Notification.accept(Observer
Forwards this notification on to a specified
Observer.
|
Observable |
Observable.doOnEach(Observer
Modifies the source Observable so that it notifies an Observer for each item it emits.
|
Subscription |
Observable.subscribe(Observer
Subscribes to an Observable and provides an Observer that implements functions to handle the items the Observable emits and any error or completion notification it issues.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BufferUntilSubscriber<T>
A solution to the "time gap" problem that occurs with
groupBy and
pivot.
|
static class |
OperatorReplay
A subject that wraps another subject.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
NotificationLite.accept(Observer
Unwraps the lite notification and calls the appropriate method on the
Observer.
|
| Constructor and Description | |
|---|---|
OperatorDoOnEach(Observer
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
RxRingBuffer.accept(Object
|
| Modifier and Type | Class and Description |
|---|---|
class |
SafeSubscriber<T>
SafeSubscriber is a wrapper around
Subscriber that ensures that the
Subscriber complies with the Rx contract.
|
class |
SerializedObserver<T>
Enforces single-threaded, serialized, ordered execution of
SerializedObserver,
SerializedObserver, and
SerializedObserver.
|
class |
SerializedSubscriber<T>
Enforces single-threaded, serialized, ordered execution of
SerializedSubscriber,
SerializedSubscriber, and
SerializedSubscriber.
|
class |
TestObserver<T>
Observer usable for unit testing to perform assertions, inspect received events or wrap a mocked Observer.
|
class |
TestSubscriber<T>
A
TestSubscriber is a variety of
Subscriber that you can use for unit testing, to perform assertions, inspect received events, or wrap a mocked
Subscriber.
|
| Modifier and Type | Method and Description |
|---|---|
static <T> Observer |
Observers.create(Action1
Creates an
Observer that receives the emissions of any
Observable it subscribes to via
onNext but ignores
onCompleted notifications; it will throw an
OnErrorNotImplementedException if
onError is invoked.
|
static <T> Observer |
Observers.create(Action1
Creates an
Observer that receives the emissions of any
Observable it subscribes to via
onNext and handles any
onError notification but ignores an
onCompleted notification.
|
static <T> Observer |
Observers.create(Action1
Creates an
Observer that receives the emissions of any
Observable it subscribes to via
onNext and handles any
onError or
onCompleted notifications.
|
static <T> Observer |
Observers.empty()
|
| Modifier and Type | Method and Description |
|---|---|
static <T> Subscriber |
Subscribers.from(Observer
Converts an
Observer into a
Subscriber.
|
| Constructor and Description | |
|---|---|
SerializedObserver(Observer
|
|
TestObserver(Observer
|
|
TestSubscriber(Observer
|
| Modifier and Type | Class and Description |
|---|---|
class |
AsyncSubject<T>
Subject that publishes only the last item observed to each
Observer that has subscribed, when the source
Observable completes.
|
class |
BehaviorSubject<T>
Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed
Observer.
|
class |
PublishSubject<T>
Subject that, once an
Observer has subscribed, emits all subsequently observed items to the subscriber.
|
class |
ReplaySubject<T>
Subject that buffers all items it observes and replays them to any
Observer that subscribes.
|
class |
SerializedSubject<T
Wraps a
Subject so that it is safe to call its various
on methods from different threads.
|
class |
Subject<T
Represents an object that is both an Observable and an Observer.
|
class |
TestSubject<T>
A variety of Subject that is useful for testing purposes.
|