Package | Description |
---|---|
io.reactivex |
Base reactive classes:
Flowable , Observable ,
Single , Maybe and
Completable ; base reactive consumers;
other common base interfaces. |
io.reactivex.flowables |
Classes supporting the Flowable base reactive class:
ConnectableFlowable and
GroupedFlowable . |
io.reactivex.internal.disposables | |
io.reactivex.internal.functions | |
io.reactivex.internal.fuseable |
Base interfaces and types for supporting operator-fusion.
|
io.reactivex.internal.observers | |
io.reactivex.internal.operators.completable | |
io.reactivex.internal.operators.flowable | |
io.reactivex.internal.operators.maybe | |
io.reactivex.internal.operators.mixed | |
io.reactivex.internal.operators.observable | |
io.reactivex.internal.operators.parallel | |
io.reactivex.internal.operators.single | |
io.reactivex.internal.schedulers | |
io.reactivex.internal.subscribers | |
io.reactivex.internal.util | |
io.reactivex.observables |
Classes supporting the Observable base reactive class:
ConnectableObservable and
GroupedObservable . |
io.reactivex.observers |
Default wrappers and implementations for Observer-based consumer classes and interfaces,
including disposable and resource-tracking variants and
the
TestObserver that allows unit testing
Observable -, Single -, Maybe -
and Completable -based flows. |
io.reactivex.parallel |
Contains the base type
ParallelFlowable ,
a sub-DSL for working with Flowable sequences in parallel. |
io.reactivex.plugins |
Contains the central plugin handler
RxJavaPlugins
class to hook into the lifecycle of the base reactive types and schedulers. |
io.reactivex.processors |
Classes extending the Flowable base reactive class and implementing
the Subscriber interface at the same time (aka hot Flowables).
|
io.reactivex.schedulers |
Contains notably the factory class of
Schedulers providing methods for
retrieving the standard scheduler instances, the TestScheduler for testing flows
with scheduling in a controlled manner and the class Timed that can hold
a value and a timestamp associated with it. |
io.reactivex.subjects |
Classes representing so-called hot sources, aka subjects, that implement a base reactive class and
the respective consumer type at once to allow forms of multicasting events to multiple
consumers as well as consuming another base reactive type of their kind.
|
io.reactivex.subscribers |
Default wrappers and implementations for Subscriber-based consumer classes and interfaces,
including disposable and resource-tracking variants and
the
TestSubscriber that allows unit testing
Flowable -based flows. |
Class and Description |
---|
BackpressureOverflowStrategy
Options to deal with buffer overflow when using onBackpressureBuffer.
|
BackpressureStrategy
Represents the options for applying backpressure to a source sequence.
|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableConverter
Convenience interface and callback used by the
Completable.as(io.reactivex.CompletableConverter<? extends R>) operator to turn a Completable into another
value fluently. |
CompletableEmitter
Abstraction over an RxJava
CompletableObserver that allows associating
a resource with it. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a CompletableEmitter instance that allows pushing
an event in a cancellation-safe manner. |
CompletableOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
CompletableTransformer
Convenience interface and callback used by the compose operator to turn a Completable into another
Completable fluently.
|
Emitter
Base interface for emitting signals in a push-fashion in various generator-like source
operators (create, generate).
|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
FlowableConverter
Convenience interface and callback used by the
Flowable.as(io.reactivex.FlowableConverter<T, ? extends R>) operator to turn a Flowable into another
value fluently. |
FlowableEmitter
Abstraction over a Reactive Streams
Subscriber that allows associating
a resource with it and exposes the current number of downstream
requested amount. |
FlowableOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a FlowableEmitter instance that allows pushing
events in a backpressure-safe and cancellation-safe manner. |
FlowableOperator
Interface to map/wrap a downstream subscriber to an upstream subscriber.
|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
FlowableTransformer
Interface to compose Flowables.
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeConverter
Convenience interface and callback used by the
Maybe.as(io.reactivex.MaybeConverter<T, ? extends R>) operator to turn a Maybe into another
value fluently. |
MaybeEmitter
Abstraction over an RxJava
MaybeObserver that allows associating
a resource with it. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a MaybeEmitter instance that allows pushing
an event in a cancellation-safe manner. |
MaybeOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
MaybeTransformer
Interface to compose Maybes.
|
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableConverter
Convenience interface and callback used by the
Observable.as(io.reactivex.ObservableConverter<T, ? extends R>) operator to turn an Observable into another
value fluently. |
ObservableEmitter
Abstraction over an RxJava
Observer that allows associating
a resource with it. |
ObservableOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of an ObservableEmitter instance that allows pushing
events in a cancellation-safe manner. |
ObservableOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
ObservableTransformer
Interface to compose Observables.
|
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Scheduler.Worker
Represents an isolated, sequential worker of a parent Scheduler for executing
Runnable tasks on
an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system). |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleConverter
Convenience interface and callback used by the
Single.as(io.reactivex.SingleConverter<T, ? extends R>) operator to turn a Single into another
value fluently. |
SingleEmitter
Abstraction over an RxJava
SingleObserver that allows associating
a resource with it. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a SingleEmitter instance that allows pushing
an event in a cancellation-safe manner. |
SingleOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
SingleTransformer
Interface to compose Singles.
|
Class and Description |
---|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Class and Description |
---|
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
Observer
Provides a mechanism for receiving push-based notifications.
|
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
Class and Description |
---|
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Class and Description |
---|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
Observer
Provides a mechanism for receiving push-based notifications.
|
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a CompletableEmitter instance that allows pushing
an event in a cancellation-safe manner. |
CompletableOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
BackpressureOverflowStrategy
Options to deal with buffer overflow when using onBackpressureBuffer.
|
BackpressureStrategy
Represents the options for applying backpressure to a source sequence.
|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Emitter
Base interface for emitting signals in a push-fashion in various generator-like source
operators (create, generate).
|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
FlowableOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a FlowableEmitter instance that allows pushing
events in a backpressure-safe and cancellation-safe manner. |
FlowableOperator
Interface to map/wrap a downstream subscriber to an upstream subscriber.
|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a MaybeEmitter instance that allows pushing
an event in a cancellation-safe manner. |
MaybeOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Observer
Provides a mechanism for receiving push-based notifications.
|
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Emitter
Base interface for emitting signals in a push-fashion in various generator-like source
operators (create, generate).
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of an ObservableEmitter instance that allows pushing
events in a cancellation-safe manner. |
ObservableOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Notification
Represents the reactive signal types: onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleOnSubscribe
A functional interface that has a
subscribe() method that receives
an instance of a SingleEmitter instance that allows pushing
an event in a cancellation-safe manner. |
SingleOperator
Interface to map/wrap a downstream observer to an upstream observer.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Scheduler.Worker
Represents an isolated, sequential worker of a parent Scheduler for executing
Runnable tasks on
an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system). |
Class and Description |
---|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
Class and Description |
---|
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
Observer
Provides a mechanism for receiving push-based notifications.
|
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
Class and Description |
---|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Class and Description |
---|
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
Observer
Provides a mechanism for receiving push-based notifications.
|
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
Class and Description |
---|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
Class and Description |
---|
Flowable
The Flowable class that implements the Reactive-Streams Pattern and offers factory methods,
intermediate operators and the ability to consume reactive dataflows.
|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Class and Description |
---|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Scheduler.Worker
Represents an isolated, sequential worker of a parent Scheduler for executing
Runnable tasks on
an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system). |
Class and Description |
---|
Completable
The
Completable class represents a deferred computation without any value but
only indication for completion or exception. |
CompletableObserver
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
|
CompletableSource
Represents a basic
Completable source base interface,
consumable via an CompletableObserver . |
Maybe
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception. |
MaybeObserver
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
|
MaybeSource
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver . |
Observable
The Observable class is the non-backpressured, optionally multi-valued base reactive class that
offers factory methods, intermediate operators and the ability to consume synchronous
and/or asynchronous reactive dataflows.
|
ObservableSource
Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer . |
Observer
Provides a mechanism for receiving push-based notifications.
|
Scheduler
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnable s to be
executed without delay (effectively as soon as possible), after a specified time delay or periodically
and represents an abstraction over an asynchronous boundary that ensures
these units of work get executed by some underlying task-execution scheme
(such as custom Threads, event loop, Executor or Actor system)
with some uniform properties and guarantees regardless of the particular underlying
scheme. |
Single
The
Single class implements the Reactive Pattern for a single value response. |
SingleObserver
Provides a mechanism for receiving push-based notification of a single value or an error.
|
SingleSource
Represents a basic
Single source base interface,
consumable via an SingleObserver . |
Class and Description |
---|
FlowableSubscriber
Represents a Reactive-Streams inspired Subscriber that is RxJava 2 only
and weakens rules §1.3 and §3.9 of the specification for gaining performance.
|
Copyright © 2019. All rights reserved.