RxJava 3 3.1.8 · io.reactivex.rxjava3.core

Base reactive classes: io.reactivex.rxjava3.core.Flowable, io.reactivex.rxjava3.core.Observable, io.reactivex.rxjava3.core.Single, io.reactivex.rxjava3.core.Maybe and io.reactivex.rxjava3.core.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

The Single and Completable reactive base types have no equivalent in Rx.NET as of 3.x.

Services which intend on exposing data asynchronously and wish to allow reactive processing and composition can implement the io.reactivex.rxjava3.core.Flowable, io.reactivex.rxjava3.core.Observable, io.reactivex.rxjava3.core.Single, io.reactivex.rxjava3.core.Maybe or io.reactivex.rxjava3.core.Completable class which then allow consumers to subscribe to them and receive events.

Usage examples can be found on the io.reactivex.rxjava3.core.Flowable/io.reactivex.rxjava3.core.Observable and org.reactivestreams.Subscriber classes.

Interface Summary

Modifier and Type	Interface and Description
public interface	CompletableConverter< the output type R> Convenience interface and callback used by the `Completable#to` operator to turn a Completable into another value fluently.
public interface	CompletableEmitter Abstraction over an RxJava `CompletableObserver` that allows associating a resource with it.
public interface	CompletableObserver Provides a mechanism for receiving push-based notification of a valueless completion or an error.
public interface	CompletableOnSubscribe A functional interface that has a `subscribe()` method that receives a `CompletableEmitter` instance that allows pushing an event in a cancellation-safe manner.
public interface	CompletableOperator Interface to map/wrap a downstream observer to an upstream observer.
public interface	CompletableSource Represents a basic `Completable` source base interface, consumable via an `CompletableObserver`.
public interface	CompletableTransformer Convenience interface and callback used by the compose operator to turn a `Completable` into another `Completable` fluently.
public interface	Emitter< the value type emitted T> Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).
public interface	FlowableConverter< the upstream type T, the output type R> Convenience interface and callback used by the `Flowable#to` operator to turn a `Flowable` into another value fluently.
public interface	FlowableEmitter< the value type to emit T> Abstraction over a Reactive Streams `org.reactivestreams.Subscriber` that allows associating a resource with it and exposes the current number of downstream requested amount.
public interface	FlowableOnSubscribe< the value type pushed T> A functional interface that has a `subscribe()` method that receives a `FlowableEmitter` instance that allows pushing events in a backpressure-safe and cancellation-safe manner.
public interface	FlowableOperator< the value type of the downstream Downstream, the value type of the upstream Upstream> Interface to map/wrap a downstream `Subscriber` to an upstream `Subscriber`.
public interface	FlowableSubscriber< the value type T> Represents a Reactive-Streams inspired `Subscriber` that is RxJava 3 only and weakens the Reactive Streams rules §1.3 and §3.9 of the specification for gaining performance.
public interface	FlowableTransformer< the upstream value type Upstream, the downstream value type Downstream> Interface to compose `Flowable`s.
public interface	MaybeConverter< the upstream type T, the output type R> Convenience interface and callback used by the `Maybe#to` operator to turn a `Maybe` into another value fluently.
public interface	MaybeEmitter< the value type to emit T> Abstraction over an RxJava `MaybeObserver` that allows associating a resource with it.
public interface	MaybeObserver< the type of item the MaybeObserver expects to observe T> Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
public interface	MaybeOnSubscribe< the value type pushed T> A functional interface that has a `subscribe()` method that receives a `MaybeEmitter` instance that allows pushing an event in a cancellation-safe manner.
public interface	MaybeOperator< the value type of the downstream Downstream, the value type of the upstream Upstream> Interface to map/wrap a downstream `MaybeObserver` to an upstream `MaybeObserver`.
public interface	MaybeSource< the element type T> Represents a basic `Maybe` source base interface, consumable via an `MaybeObserver`.
public interface	MaybeTransformer< the upstream value type Upstream, the downstream value type Downstream> Interface to compose `Maybe`s.
public interface	ObservableConverter< the upstream type T, the output type R> Convenience interface and callback used by the `Observable#to` operator to turn an `Observable` into another value fluently.
public interface	ObservableEmitter< the value type to emit T> Abstraction over an RxJava `Observer` that allows associating a resource with it.
public interface	ObservableOnSubscribe< the value type pushed T> A functional interface that has a `subscribe()` method that receives an `ObservableEmitter` instance that allows pushing events in a cancellation-safe manner.
public interface	ObservableOperator< the value type of the downstream Downstream, the value type of the upstream Upstream> Interface to map/wrap a downstream `Observer` to an upstream `Observer`.
public interface	ObservableSource< the element type T> Represents a basic, non-backpressured `Observable` source base interface, consumable via an `Observer`.
public interface	ObservableTransformer< the upstream value type Upstream, the downstream value type Downstream> Interface to compose `Observable`s.
public interface	Observer< the type of item the Observer expects to observe T> Provides a mechanism for receiving push-based notifications.
public interface	SingleConverter< the upstream type T, the output type R> Convenience interface and callback used by the `Single#to` operator to turn a `Single` into another value fluently.
public interface	SingleEmitter< the value type to emit T> Abstraction over an RxJava `SingleObserver` that allows associating a resource with it.
public interface	SingleObserver< the type of item the SingleObserver expects to observe T> Provides a mechanism for receiving push-based notification of a single value or an error.
public interface	SingleOnSubscribe< the value type pushed T> A functional interface that has a `subscribe()` method that receives a `SingleEmitter` instance that allows pushing an event in a cancellation-safe manner.
public interface	SingleOperator< the value type of the downstream Downstream, the value type of the upstream Upstream> Interface to map/wrap a downstream `SingleObserver` to an upstream `SingleObserver`.
public interface	SingleSource< the element type T> Represents a basic `Single` source base interface, consumable via an `SingleObserver`.
public interface	SingleTransformer< the upstream value type Upstream, the downstream value type Downstream> Interface to compose `Single`s.

Class Summary

Modifier and Type	Class and Description
public abstract class	Completable The `Completable` class represents a deferred computation without any value but only indication for completion or exception.
public abstract class	Flowable< the type of the items emitted by the `Flowable` T> The `Flowable` class that implements the Reactive Streams `Publisher` Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
public abstract class	Maybe< the value type T> The `Maybe` class represents a deferred computation and emission of a single value, no value at all or an exception.
public class	Notification< the value type T> Represents the reactive signal types: `onNext`, `onError` and `onComplete` and holds their parameter values (a value, a `Throwable`, nothing).
public abstract class	Observable< the type of the items emitted by the `Observable` T> 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.
public abstract class	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.
public abstract class	Single< the type of the item emitted by the `Single` T> The `Single` class implements the Reactive Pattern for a single value response.

Modifier and Type	Enum and Description
public enum	BackpressureOverflowStrategy Options to deal with buffer overflow when using onBackpressureBuffer.
public enum	BackpressureStrategy Represents the options for applying backpressure to a source sequence.

Package io.reactivex.rxjava3.core

Interface Summary

Class Summary

Enum Summary