io.reactivex.rxjava3.core (RxJava Javadoc 3.1.9)

Interface Summary
Interface	Description
CompletableConverter<R>	Convenience interface and callback used by the `Completable.to(io.reactivex.rxjava3.core.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 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<T>	Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).
FlowableConverter<T,R>	Convenience interface and callback used by the `Flowable.to(io.reactivex.rxjava3.core.FlowableConverter<T, ? extends R>)` operator to turn a `Flowable` into another value fluently.
FlowableEmitter<T>	Abstraction over a Reactive Streams `Subscriber` that allows associating a resource with it and exposes the current number of downstream requested amount.
FlowableOnSubscribe<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.
FlowableOperator<Downstream,Upstream>	Interface to map/wrap a downstream `Subscriber` to an upstream `Subscriber`.
FlowableSubscriber<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.
FlowableTransformer<Upstream,Downstream>	Interface to compose `Flowable`s.
MaybeConverter<T,R>	Convenience interface and callback used by the `Maybe.to(io.reactivex.rxjava3.core.MaybeConverter<T, ? extends R>)` operator to turn a `Maybe` into another value fluently.
MaybeEmitter<T>	Abstraction over an RxJava `MaybeObserver` that allows associating a resource with it.
MaybeObserver<T>	Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
MaybeOnSubscribe<T>	A functional interface that has a `subscribe()` method that receives a `MaybeEmitter` instance that allows pushing an event in a cancellation-safe manner.
MaybeOperator<Downstream,Upstream>	Interface to map/wrap a downstream `MaybeObserver` to an upstream `MaybeObserver`.
MaybeSource<T>	Represents a basic `Maybe` source base interface, consumable via an `MaybeObserver`.
MaybeTransformer<Upstream,Downstream>	Interface to compose `Maybe`s.
ObservableConverter<T,R>	Convenience interface and callback used by the `Observable.to(io.reactivex.rxjava3.core.ObservableConverter<T, ? extends R>)` operator to turn an `Observable` into another value fluently.
ObservableEmitter<T>	Abstraction over an RxJava `Observer` that allows associating a resource with it.
ObservableOnSubscribe<T>	A functional interface that has a `subscribe()` method that receives an `ObservableEmitter` instance that allows pushing events in a cancellation-safe manner.
ObservableOperator<Downstream,Upstream>	Interface to map/wrap a downstream `Observer` to an upstream `Observer`.
ObservableSource<T>	Represents a basic, non-backpressured `Observable` source base interface, consumable via an `Observer`.
ObservableTransformer<Upstream,Downstream>	Interface to compose `Observable`s.
Observer<T>	Provides a mechanism for receiving push-based notifications.
SingleConverter<T,R>	Convenience interface and callback used by the `Single.to(io.reactivex.rxjava3.core.SingleConverter<T, ? extends R>)` operator to turn a `Single` into another value fluently.
SingleEmitter<T>	Abstraction over an RxJava `SingleObserver` that allows associating a resource with it.
SingleObserver<T>	Provides a mechanism for receiving push-based notification of a single value or an error.
SingleOnSubscribe<T>	A functional interface that has a `subscribe()` method that receives a `SingleEmitter` instance that allows pushing an event in a cancellation-safe manner.
SingleOperator<Downstream,Upstream>	Interface to map/wrap a downstream `SingleObserver` to an upstream `SingleObserver`.
SingleSource<T>	Represents a basic `Single` source base interface, consumable via an `SingleObserver`.
SingleTransformer<Upstream,Downstream>	Interface to compose `Single`s.

Class Summary
Class	Description
Completable	The `Completable` class represents a deferred computation without any value but only indication for completion or exception.
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.
Maybe<T>	The `Maybe` class represents a deferred computation and emission of a single value, no value at all or an exception.
Notification<T>	Represents the reactive signal types: `onNext`, `onError` and `onComplete` and holds their parameter values (a value, a `Throwable`, nothing).
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.
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<T>	The `Single` class implements the Reactive Pattern for a single value response.

Enum Summary
Enum	Description
BackpressureOverflowStrategy	Options to deal with buffer overflow when using onBackpressureBuffer.
BackpressureStrategy	Represents the options for applying backpressure to a source sequence.

Package io.reactivex.rxjava3.core Description

Base reactive classes: 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

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 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.