Package io.reactivex.rxjava3.core
Flowable
, Observable
,
Single
, Maybe
and
Completable
; base reactive consumers;
other common base interfaces.
A library that enables subscribing to and composing asynchronous events and callbacks.
The Flowable/Subscriber, Observable/Observer, Single/SingleObserver and
Completable/CompletableObserver interfaces and associated operators (in
the io.reactivex.internal.operators
package) are inspired by the
Reactive Rx library in Microsoft .NET but designed and implemented on
the more advanced Reactive-Streams ( http://www.reactivestreams.org ) principles.
More information can be found at http://msdn.microsoft.com/en-us/data/gg577609.
Compared with the Microsoft implementation:
- Observable == IObservable (base type)
- Observer == IObserver (event consumer)
- Disposable == IDisposable (resource/cancellation management)
- Observable == Observable (factory methods)
- Flowable == IAsyncEnumerable (backpressure)
- Subscriber == IAsyncEnumerator
Services which intend on exposing data asynchronously and wish
to allow reactive processing and composition can implement the
Flowable
, Observable
, Single
,
Maybe
or Completable
class which then allow
consumers to subscribe to them and receive events.
Usage examples can be found on the Flowable
/Observable
and Subscriber
classes.
-
ClassDescriptionOptions to deal with buffer overflow when using onBackpressureBuffer.Represents the options for applying backpressure to a source sequence.The
Completable
class represents a deferred computation without any value but only indication for completion or exception.Convenience interface and callback used by theCompletable.to(io.reactivex.rxjava3.core.CompletableConverter<? extends R>)
operator to turn a Completable into another value fluently.Abstraction over an RxJavaCompletableObserver
that allows associating a resource with it.Provides a mechanism for receiving push-based notification of a valueless completion or an error.A functional interface that has asubscribe()
method that receives aCompletableEmitter
instance that allows pushing an event in a cancellation-safe manner.Interface to map/wrap a downstream observer to an upstream observer.Represents a basicCompletable
source base interface, consumable via anCompletableObserver
.Convenience interface and callback used by the compose operator to turn aCompletable
into anotherCompletable
fluently.Emitter<T>Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).Flowable<T>TheFlowable
class that implements the Reactive StreamsPublisher
Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.FlowableConverter<T,R> Convenience interface and callback used by theFlowable.to(io.reactivex.rxjava3.core.FlowableConverter<T, ? extends R>)
operator to turn aFlowable
into another value fluently.Abstraction over a Reactive StreamsSubscriber
that allows associating a resource with it and exposes the current number of downstream requested amount.A functional interface that has asubscribe()
method that receives aFlowableEmitter
instance that allows pushing events in a backpressure-safe and cancellation-safe manner.FlowableOperator<Downstream,Upstream> Interface to map/wrap a downstreamSubscriber
to an upstreamSubscriber
.FlowableTransformer<Upstream,Downstream> Interface to composeFlowable
s.Maybe<T>TheMaybe
class represents a deferred computation and emission of a single value, no value at all or an exception.MaybeConverter<T,R> Convenience interface and callback used by theMaybe.to(io.reactivex.rxjava3.core.MaybeConverter<T, ? extends R>)
operator to turn aMaybe
into another value fluently.MaybeEmitter<T>Abstraction over an RxJavaMaybeObserver
that allows associating a resource with it.Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.A functional interface that has asubscribe()
method that receives aMaybeEmitter
instance that allows pushing an event in a cancellation-safe manner.MaybeOperator<Downstream,Upstream> Interface to map/wrap a downstreamMaybeObserver
to an upstreamMaybeObserver
.MaybeSource<T>Represents a basicMaybe
source base interface, consumable via anMaybeObserver
.MaybeTransformer<Upstream,Downstream> Interface to composeMaybe
s.Notification<T>Represents the reactive signal types:onNext
,onError
andonComplete
and holds their parameter values (a value, aThrowable
, nothing).Observable<T>TheObservable
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<T,R> Convenience interface and callback used by theObservable.to(io.reactivex.rxjava3.core.ObservableConverter<T, ? extends R>)
operator to turn anObservable
into another value fluently.Abstraction over an RxJavaObserver
that allows associating a resource with it.A functional interface that has asubscribe()
method that receives anObservableEmitter
instance that allows pushing events in a cancellation-safe manner.ObservableOperator<Downstream,Upstream> Interface to map/wrap a downstreamObserver
to an upstreamObserver
.Represents a basic, non-backpressuredObservable
source base interface, consumable via anObserver
.ObservableTransformer<Upstream,Downstream> Interface to composeObservable
s.Observer<T>Provides a mechanism for receiving push-based notifications.AScheduler
is an object that specifies an API for scheduling units of work provided in the form ofRunnable
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.Represents an isolated, sequential worker of a parent Scheduler for executingRunnable
tasks on an underlying task-execution scheme (such as custom Threads, event loop,Executor
or Actor system).Single<T>TheSingle
class implements the Reactive Pattern for a single value response.SingleConverter<T,R> Convenience interface and callback used by theSingle.to(io.reactivex.rxjava3.core.SingleConverter<T, ? extends R>)
operator to turn aSingle
into another value fluently.Abstraction over an RxJavaSingleObserver
that allows associating a resource with it.Provides a mechanism for receiving push-based notification of a single value or an error.A functional interface that has asubscribe()
method that receives aSingleEmitter
instance that allows pushing an event in a cancellation-safe manner.SingleOperator<Downstream,Upstream> Interface to map/wrap a downstreamSingleObserver
to an upstreamSingleObserver
.SingleSource<T>Represents a basicSingle
source base interface, consumable via anSingleObserver
.SingleTransformer<Upstream,Downstream> Interface to composeSingle
s.