All Classes and Interfaces
Class
Description
Abstract base class for operators that throttle excessive updates from upstream in case if
downstream
Subscriber is not ready to receive updates.Base functionality for direct tasks that manage a runnable and cancellation/completion.
Wraps lambda callbacks and when the upstream terminates or the observer gets disposed,
removes itself from a
CompositeDisposable.Represents an empty, async-only
QueueFuseable instance.Abstract base class for operators that take an upstream
source
Publisher.Abstract base class for intermediate Maybe operators that take an upstream MaybeSource.
Base class for operators with a source consumable.
A functional interface similar to Runnable but allows throwing a checked exception.
A Disposable container that manages an
Action instance.A linked-array-list implementation that only supports appending and consumption.
Predicate interface suppressing the exception.
A composite disposable with a fixed number of slots.
A composite disposable with a fixed number of slots.
Processor that emits the very last value followed by a completion event or the received error
to
Subscribers.A Subject that emits the very last value followed by a completion event or the received error to Observers.
A subscription implementation that arbitrates exactly one other Subscription and can
hold a single disposable resource.
Atomic container for Throwables including combining and having a
terminal state via ExceptionHelper.
A disposable container that manages an
AutoCloseable instance.Utility class to help with backpressure-related operations such as request aggregation.
Enumeration for various kinds of backpressure support.
Options to deal with buffer overflow when using onBackpressureBuffer.
Represents the options for applying backpressure to a source sequence.
Indicates the backpressure support kind of the associated operator or class.
Base class with shared infrastructure to support
TestSubscriber and TestObserver.Base class for a fuseable intermediate subscriber.
Base class for a fuseable intermediate observer.
Base class for a fuseable intermediate subscriber.
An abstract QueueDisposable implementation, extending an AtomicInteger,
that defaults all unnecessary Queue methods to throw UnsupportedOperationException.
Base class extending AtomicInteger (wip or request accounting) and QueueSubscription (fusion).
An abstract QueueDisposable implementation that defaults all
unnecessary Queue methods to throw UnsupportedOperationException.
Base class extending AtomicLong (wip or request accounting) and QueueSubscription (fusion).
Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed
Subscriber.Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed
Observer.Indicates the feature is in beta state: it will be most likely stay but
the signature may change between versions without warning.
A functional interface (callback) that accepts two values (of possibly different types).
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that returns true or false for the given input values.
Blocks until the upstream terminates and dispatches the outcome to
the actual observer.
Blocks until the upstream signals its first value or completes.
Blocks until the upstream signals its first value or completes.
Wait for and iterate over the latest values of the source observable.
Subscriber of source, iterator for output.
Returns an Iterable that always returns the item most recently emitted by an Observable, or a
seed value if no item has yet been emitted.
Returns an Iterable that blocks until the Observable emits another item, then returns that item.
Utility methods for helping common blocking operations.
Stores an incoming Throwable (if any) and counts itself down.
Blocks until the upstream signals its last value or completes.
Blocks until the upstream signals its last value or completes.
A combined Observer that awaits the success or error signal via a CountDownLatch.
Wait for and iterate over the latest values of the source observable.
Returns an Iterable that always returns the item most recently emitted by an Observable, or a
seed value if no item has yet been emitted.
Returns an Iterable that blocks until the Observable emits another item, then returns that item.
Subscription implementation that ignores request but remembers the cancellation
which can be checked via isCancelled.
A functional interface (callback) that returns a boolean value.
A functional interface that has a single cancel method
that can throw.
A disposable container that wraps a Cancellable instance.
Represents an empty, async-only
QueueFuseable instance that tracks and exposes a
canceled/disposed state.Marks methods whose return values should be checked.
The
Completable class represents a deferred computation without any value but
only indication for completion or exception.After Completable completes, it relays the signals
of the ObservableSource to the downstream observer.
After Completable completes, it relays the signals
of the Publisher to the downstream subscriber.
Consume the upstream source exactly once and cache its terminal event.
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.Breaks the references between the upstream and downstream when the Completable terminates.
Execute an action after an onError, onComplete or a dispose event.
Abstraction over an RxJava
CompletableObserver that allows associating
a resource with it.Wrap a CompletionStage and signal its outcome.
Call a Supplier for each incoming CompletableObserver and signal completion or the thrown exception.
Hides the identity of the upstream Completable and its Disposable sent through onSubscribe.
Turn the signal types of a Completable source into a single Notification of
equal kind.
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
Returns a value generated via a function if the main source signals an onError.
A functional interface that has a
subscribe() method that receives
a CompletableEmitter instance that allows pushing
an event in a cancellation-safe manner.Interface to map/wrap a downstream observer to an upstream observer.
Represents a basic
Completable source base interface,
consumable via an CompletableObserver.Represents a hot Completable-like source and consumer of events similar to Subjects.
Terminates the sequence if either the main or the other Completable terminate.
Signals an
onComplete event after the specified delay.Wraps a Completable and exposes it as an Observable.
Convenience interface and callback used by the compose operator to turn a
Completable into another
Completable fluently.Class that extends CompletableFuture and converts multiple types of reactive consumers
and their signals into completion signals.
A disposable container that can hold onto multiple other
Disposables and
offers O(1) time complexity for CompositeDisposable.add(Disposable), CompositeDisposable.remove(Disposable) and CompositeDisposable.delete(Disposable)
operations.Represents an exception that is a composite of one or more other exceptions.
Contains a formatted message with a simplified representation of the exception graph
contained within the CompositeException.
Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation.
Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation.
Holds a fixed pool of worker threads and assigns them
to requested Scheduler.Workers in a round-robin fashion.
Base class for implementing concatMapX main observers.
Base class for implementing concatMapX main subscribers.
A
FlowableSubscriber with an additional ConditionalSubscriber.tryOnNext(Object) method that
tells the caller the specified value has been accepted or not.A
ConnectableFlowable resembles an ordinary Flowable, except that it does not begin
emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.A
ConnectableObservable resembles an ordinary Observable, except that it does not begin
emitting items when it is subscribed to, but only when its ConnectableObservable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.Store the Disposable received from the connection.
A functional interface (callback) that accepts a single value.
Abstract base implementation of an
Observer with support for cancelling a
subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart()
when the subscription happens.Abstract base implementation of a
Subscriber with
support for requesting via DefaultSubscriber.request(long), cancelling via
via DefaultSubscriber.cancel() (both synchronously) and calls DefaultSubscriber.onStart()
when the subscription happens.Represents a fuseable container for a single value.
A fuseable Observer that can generate 0 or 1 resulting value.
A subscriber, extending a DeferredScalarSubscription,
that is unbounded-in and can generate 0 or 1 resulting value.
A subscription that signals a single value eventually.
Represents a disposable resource.
Wraps lambda callbacks and when the upstream terminates or this (Single | Maybe | Completable)
observer gets disposed, removes itself from a
CompositeDisposable.Wraps lambda callbacks and when the upstream terminates or this observer gets disposed,
removes itself from a
CompositeDisposable.Wraps lambda callbacks and when the upstream terminates or this subscriber gets disposed,
removes itself from a
CompositeDisposable.An abstract
CompletableObserver that allows asynchronous cancellation by implementing Disposable.Common interface to add and remove disposables from a container.
Utility methods for working with Disposables atomically.
An abstract
MaybeObserver that allows asynchronous cancellation by implementing Disposable.An abstract
Observer that allows asynchronous cancellation by implementing Disposable.An abstract
SingleObserver that allows asynchronous cancellation by implementing Disposable.An abstract Subscriber that allows asynchronous, external cancellation by implementing
Disposable.Implements the Future interface and calls dispose() on cancel() but
the other methods are not implemented.
Base interface for emitting signals in a push-fashion in various generator-like source
operators (create, generate).
Singleton implementing many interfaces as empty.
Represents a stateless empty Disposable that reports being always
empty and disposed.
An empty subscription that does nothing other than validates the request amount.
Utility class to help report multiple subscriptions with the same
consumer type instead of the internal "Disposable already set!" message
that is practically reserved for internal operators and indicate bugs in them.
Indicates when an error from the main source should be reported.
Terminal atomics for Throwable containers.
Utility class to help propagate checked exceptions and rethrow exceptions
designated as fatal.
Wraps an Executor and provides the Scheduler API over it.
Wrapper for a
Runnable with additional logic for handling interruption on
a shared thread, similar to how Java Executors do it.Indicates the feature is in experimental state: its existence, signature or behavior
might change without warning from one release to the next.
The
Flowable class that implements the Reactive Streams Publisher
Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.Wraps a
ConnectableFlowable and calls its connect() method once
the specified number of Subscribers have subscribed.Utility methods to consume a Publisher in a blocking manner with callbacks or Subscriber.
An observable which auto-connects to another observable, caches the elements
from that observable but allows terminating the connection and completing the cache.
Hosts the downstream consumer and its current requested and replay states.
Represents a segment of the cached item list as
part of a linked-node-list structure.
Collect items into a container defined by a Stream
Collector callback set.Collect items into a container defined by a Stream
Collector callback set.Combines the latest values from multiple sources through a function.
Maps the upstream items into
CompletableSources and subscribes to them one after the
other completes or terminates (in error-delaying mode).ConcatMapEager which works with an arbitrary Publisher source.
Maps each upstream item into a
MaybeSource, subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate.Maps each upstream item into a
MaybeSource, subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate.Maps each upstream item into a
SingleSource, subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate.Maps each upstream item into a
SingleSource, subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate.Subscribe to a main Flowable first, then when it completes normally, subscribe to a Completable
and terminate when it terminates.
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Maybe,
signal its success value followed by a completion or signal its error or completion signal as is.
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Single,
signal its success value followed by a completion or signal its error as is.
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.Serializes calls to onNext, onError and onComplete.
Delays the subscription to the main source until the other
observable fires an event or completes.
Calls a consumer after pushing the current item to the downstream.
Execute an action after an onError, onComplete or a cancel event.
Emits the indexth element from a Publisher as a Maybe.
Abstraction over a Reactive Streams
Subscriber that allows associating
a resource with it and exposes the current number of downstream
requested amount.A source Flowable that signals an onSubscribe() + onComplete() only.
Signals the first element of the source via the underlying CompletableFuture,
signals the a default item if the upstream is empty or signals
NoSuchElementException.Maps a sequence of values into CompletableSources and awaits their termination.
Maps a sequence of values into CompletableSources and awaits their termination.
Maps upstream values into MaybeSources and merges their signals into one sequence.
Maps upstream values into MaybeSources and merges their signals into one sequence.
Maps upstream values into SingleSources and merges their signals into one sequence.
Maps upstream values into SingleSources and merges their signals into one sequence.
Maps the upstream values onto
Streams and emits their items in order to the downstream.Executes an
Action and signals its exception or completes normally.Wrap a Completable into a Flowable.
Wrap a CompletionStage and signal its outcome.
Executes an
Runnable and signals its exception or completes normally.Wraps a
Stream and emits its values as a Flowable sequence.Call a Supplier for each incoming Subscriber and signal the returned value or the thrown exception.
Hides the identity of the wrapped Flowable and its Subscription.
Helper utility class to support Flowable with inner classes.
Represents a constant scalar value.
Consumes the source Publisher and emits its last item or completes.
Consumes the source Publisher and emits its last item or the defaultItem
if empty.
Signals the last element of the source via the underlying CompletableFuture,
signals the a default item if the upstream is empty or signals
NoSuchElementException.Allows lifting operators into a chain of Publishers.
Map the upstream values into an Optional and emit its value if any.
Map working with an arbitrary Publisher source.
Merges a Flowable and a Completable by emitting the items of the Flowable and waiting until
both the Flowable and Completable complete normally.
Merges an Observable and a Maybe by emitting the items of the Observable and the success
value of the Maybe and waiting until both the Observable and Maybe terminate normally.
Merges an Observable and a Maybe by emitting the items of the Observable and the success
value of the Maybe and waiting until both the Observable and Maybe terminate normally.
Handle backpressure with a bounded buffer and custom strategy.
Emits an onComplete if the source emits an onError and the predicate returns true for
that Throwable.
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.Interface to map/wrap a downstream
Subscriber to an upstream Subscriber.Represents a Subscriber and a Flowable (Publisher) at the same time, allowing
multicasting events from a single source to multiple child Subscribers.
Shares a single underlying connection to the upstream Publisher
and multicasts events to all subscribed subscribers until the upstream
completes or the connection is disposed.
Multicasts a Flowable over a selector function.
Emits a range of integer values.
Emits a range of long values.
Reduces a sequence via a function into a single value or signals NoSuchElementException for
an empty source.
Reduce a Flowable into a single value exposed as Single or signal NoSuchElementException.
Reduce a sequence of values, starting from a seed value and by using
an accumulator function and return the last accumulated value.
Reduce a sequence of values, starting from a generated seed value and by using
an accumulator function and return the last accumulated value.
Returns an observable sequence that stays connected to the source as long as
there is at least one subscription to the observable sequence.
Base class for bounded buffering with options to specify an
enter and leave transforms and custom truncation behavior.
A Subscription that manages the request and cancellation state of a
child subscriber in thread-safe manner.
Represents a node in a bounded replay buffer's linked list.
The interface for interacting with various buffering logic.
Size and time bound replay buffer.
A bounded replay buffer implementation with size limit only.
Holds an unbounded list of events.
Utility classes to work with scalar-sourced XMap operators (where X == { flat, concat, switch }).
Maps a scalar value to a Publisher and subscribes to it.
Provides callbacks for the EqualSubscribers.
Signals the only element of the source via the underlying CompletableFuture,
signals the a default item if the upstream is empty or signals
IllegalArgumentException
if the upstream has more than one item.Base class that extends CompletableFuture and provides basic infrastructure
to notify watchers upon upstream signals.
Subscribes to the source Flowable on the specified Scheduler and makes
sure downstream requests are scheduled there as well.
Maps the upstream values into
CompletableSources, subscribes to the newer one while
disposing the subscription to the previous CompletableSource, thus keeping at most one
active CompletableSource running.Switch between subsequent
CompletableSources emitted by a Publisher.Maps the upstream items into
MaybeSources and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value if available, optionally delaying
errors from the main source or the inner sources.Switch between subsequent
MaybeSources emitted by a Publisher.Maps the upstream items into
SingleSources and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value, optionally delaying
errors from the main source or the inner sources.Switch between subsequent
SingleSources emitted by a Publisher.Take with a generic Publisher source.
Emits the next or latest item when the given time elapses.
Interface to compose
Flowables.Wrapper for a FlowableProcessor that detects an incoming subscriber.
Combines a main sequence of values with the latest from multiple other sequences via
a selector function.
A functional interface that takes a value and returns another value, possibly with a
different type and allows throwing a checked exception.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
Utility methods to convert the BiFunction, Function3..Function9 instances to Function of Object array.
Interface indicating a operator implementation can be macro-fused back to Flowable in case
the operator goes from Flowable to some other reactive type and then the sequence calls
for toFlowable again:
Interface indicating an operator implementation can be macro-fused back to Maybe in case
the operator goes from Maybe to some other reactive type and then the sequence calls
for toMaybe again:
Interface indicating a operator implementation can be macro-fused back to Observable in case
the operator goes from Observable to some other reactive type and then the sequence calls
for toObservable again:
A Disposable container that cancels a
Future instance.An Observer + Future that expects exactly one upstream value and provides it
via the (blocking) Future API.
An Observer + Future that expects exactly one upstream value and provides it
via the (blocking) Future API.
A Subscriber + Future that expects exactly one upstream value and provides it
via the (blocking) Future API.
A
Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().An
Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().Utility methods to perform half-serialization: a form of serialization
where onNext is guaranteed to be called from a single thread but
onError or onComplete may be called from any threads.
Interface indicating the implementor has an upstream CompletableSource-like source available
via
HasUpstreamCompletableSource.source() method.Interface indicating the implementor has an upstream MaybeSource-like source available
via
HasUpstreamMaybeSource.source() method.Interface indicating the implementor has an upstream ObservableSource-like source available
via
HasUpstreamObservableSource.source() method.Interface indicating the implementor has an upstream Publisher-like source available
via
HasUpstreamPublisher.source() method.Interface indicating the implementor has an upstream SingleSource-like source available
via
HasUpstreamSingleSource.source() method.A Scheduler partially implementing the API by allowing only non-delayed, non-periodic
task execution on the current thread immediately.
Subscriber that can fuse with the upstream and calls a support interface
whenever an event is available.
Interface to allow the InnerQueuedSubscriber to call back a parent
with signals.
Subscriber that can fuse with the upstream and calls a support interface
whenever an event is available.
Interface to allow the InnerQueuedSubscriber to call back a parent
with signals.
Wrapper for a regular task that gets immediately rescheduled when the task completed.
A functional interface (callback) that takes a primitive value and return value of type T.
Scheduler that creates and caches a set of thread pools and reuses them if possible.
An interface that indicates that the implementing type is composed of individual components and exposes information
about their behavior.
A list implementation which combines an ArrayList with a LinkedList to
avoid copying values when the capacity needs to be increased.
A disposable container that can hold onto multiple other disposables.
A functional interface (callback) that consumes a primitive long value.
A consumer that implements the consumer types of Maybe, Single and Completable
and turns their signals into Notifications for a SingleObserver.
The
Maybe class represents a deferred computation and emission of a single value, no value at all or an exception.Signals the event of the first MaybeSource that signals.
Consumes the source once and replays its signal to any current or future MaybeObservers.
MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
Concatenate values of each MaybeSource provided in an array.
Concatenate values of each MaybeSource provided in an array and delays
any errors till the very end.
Concatenate values of each MaybeSource provided by an Iterable.
Signals true if the source signals a value that is object-equals with the provided
value, false otherwise or for empty sources.
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.Signals 1L if the source signalled an item or 0L if the source is empty.
Provides an API over MaybeObserver that serializes calls to onXXX and manages cancellation
in a safe manner.
Defers the creation of the actual Maybe the incoming MaybeObserver is subscribed to.
Delays all signal types by the given amount and re-emits them on the given scheduler.
Delay the emission of the main signal until the other signals an item or completes.
Delay the subscription to the main Maybe until the other signals an item or completes.
Maps the success value of the source to a Notification, then
maps it back to the corresponding signal type.
Breaks the references between the upstream and downstream when the Maybe terminates.
Calls a consumer after pushing the current item to the downstream.
Execute an action after an onSuccess, onError, onComplete or a dispose event.
Calls a BiConsumer with the success, error values of the upstream Maybe or with two nulls if
the Maybe completed.
Invokes callbacks upon
onSubscribe from upstream and
dispose from downstream.Abstraction over an RxJava
MaybeObserver that allows associating
a resource with it.Signals an onComplete.
Compares two MaybeSources to see if they are both empty or emit the same value compared
via a BiPredicate.
Signals a constant Throwable.
Signals a Throwable returned by a Supplier.
Filters the upstream via a predicate, returning the success item or completing if
the predicate returns false.
Filters the upstream SingleSource via a predicate, returning the success item or completing if
the predicate returns false.
Maps a source item to another MaybeSource then calls a BiFunction with the
original item and the secondary item to generate the final result.
Maps the success value of the source MaybeSource into a Completable.
Maps a success value into an Iterable and streams it back as a Flowable.
Maps a success value into an Iterable and streams it back as a Flowable.
Maps a value into a MaybeSource and relays its signal.
Maps the success value of a Maybe onto an ObservableSource and
relays its signals to the downstream observer.
Maps the success value of a Maybe onto a Publisher and
relays its signals to the downstream subscriber.
Maps the success value of the source MaybeSource into a Single.
Maps a value into a MaybeSource and relays its signal.
Map the success value into a Java
Stream and emits its values.Map the success value into a Java
Stream and emits its values.Executes an Action and signals its exception or completes normally.
Executes a callable and signals its value as success or signals an exception.
Wrap a Completable into a Maybe.
Wrap a CompletionStage and signal its outcome.
Waits until the source Future completes or the wait times out; treats a
null
result as indication to signal onComplete instead of onSuccess.Executes an Runnable and signals its exception or completes normally.
Wrap a Single into a Maybe.
Executes a supplier and signals its value as success or signals an exception.
Hides the identity of the upstream Maybe and its Disposable sent through onSubscribe.
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
Signals true if the source Maybe signals onComplete, signals false if the source Maybe
signals onSuccess.
Signals true if the source Maybe signals onComplete, signals false if the source Maybe
signals onSuccess.
Signals a constant value.
Calls a MaybeOperator for the incoming MaybeObserver.
Maps the upstream success value into some other value.
Maps the success value to an
Optional and emits its non-empty value or completes.Turn the signal types of a Maybe source into a single Notification of
equal kind.
Run all MaybeSources of an array at once and signal their values as they become available.
Doesn't signal any event other than onSubscribe.
Signals the onSuccess, onError or onComplete events on a the specific scheduler.
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
Emits an onComplete if the source emits an onError and the predicate returns true for
that Throwable.
Subscribes to the MaybeSource returned by a function if the main source signals an onError.
Returns a value generated via a function if the main source signals an onError.
A functional interface that has a
subscribe() method that receives
a MaybeEmitter instance that allows pushing
an event in a cancellation-safe manner.Interface to map/wrap a downstream
MaybeObserver to an upstream MaybeObserver.Peeks into the lifecycle of a Maybe and MaybeObserver.
Represents a basic
Maybe source base interface,
consumable via an MaybeObserver.Represents a hot Maybe-like source and consumer of events similar to Subjects.
Subscribes to the upstream MaybeSource on the specified scheduler.
Subscribes to the other source if the main source is empty.
Subscribes to the other source if the main source is empty.
Relays the main source's event unless the other Maybe signals an item first or just completes
at which point the resulting Maybe is completed.
Relays the main source's event unless the other Publisher signals an item first or just completes
at which point the resulting Maybe is completed.
Measures the time between subscription and the success item emission
from the upstream and emits this as a
Timed success value.Switches to the fallback Maybe if the other MaybeSource signals a success or completes, or
signals TimeoutException if fallback is null.
Switches to the fallback Maybe if the other Publisher signals a success or completes, or
signals TimeoutException if fallback is null.
Signals a
0L after the specified delay.Wraps a MaybeSource and exposes it as a Flowable, relaying signals in a backpressure-aware manner
and composes cancellation through.
Wraps a MaybeSource and exposes it as an Observable, relaying signals in a backpressure-aware manner
and composes cancellation through.
Helper function to merge/concat values of each MaybeSource provided by a Publisher.
Wraps a MaybeSource and exposes its onSuccess and onError signals and signals
NoSuchElementException for onComplete if
defaultValue is null.Interface to compose
Maybes.Wraps a MaybeSource without safeguard and calls its subscribe() method for each MaybeObserver.
Makes sure a dispose() call from downstream happens on the specified scheduler.
Creates a resource and a dependent Maybe for each incoming Observer and optionally
disposes the resource eagerly (before the terminal event is send out).
A BiFunction that merges two Lists into a new list.
Indicates that an operator attempted to emit a value but the downstream wasn't ready for it.
A multi-producer single consumer unbounded queue.
A
FlowableProcessor implementation that coordinates downstream requests through
a front-buffer and stable-prefetching, optionally canceling the upstream if all
subscribers have cancelled.Schedules work on a new thread.
Base class that manages a single-threaded ScheduledExecutorService as a
worker but doesn't perform task-tracking operations.
Marker interface to indicate blocking is not recommended while running
on a Scheduler with a thread type implementing it.
Indicates that a field/parameter/variable/type parameter/return type is never null.
Represents the reactive signal types:
onNext, onError and onComplete and
holds their parameter values (a value, a Throwable, nothing).Lightweight notification handling utility class.
Wraps a Disposable.
Wraps a Throwable.
Wraps a Subscription.
Indicates that a field/parameter/variable/type parameter/return type may be null.
Utility methods containing the backport of Java 7's Objects utility class.
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.Wraps a ConnectableObservable and calls its connect() method once
the specified number of Observers have subscribed.
Utility methods to consume an Observable in a blocking manner with callbacks or Observer.
An observable which auto-connects to another observable, caches the elements
from that observable but allows terminating the connection and completing the cache.
Hosts the downstream consumer and its current requested and replay states.
Represents a segment of the cached item list as
part of a linked-node-list structure.
Collect items into a container defined by a Stream
Collector callback set.Collect items into a container defined by a Stream
Collector callback set.Maps the upstream items into
CompletableSources and subscribes to them one after the
other completes or terminates (in error-delaying mode).Maps each upstream item into a
MaybeSource, subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate.Maps each upstream item into a
SingleSource, subscribes to them one after the other terminates
and relays their success values, optionally delaying any errors till the main and inner sources
terminate.Subscribe to a main Observable first, then when it completes normally, subscribe to a Single,
signal its success value followed by a completion or signal its error as is.
Subscribe to a main Observable first, then when it completes normally, subscribe to a Maybe,
signal its success value followed by a completion or signal its error or completion signal as is.
Subscribe to a main Observable first, then when it completes normally, subscribe to a Single,
signal its success value followed by a completion or signal its error as is.
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.Serializes calls to onNext, onError and onComplete.
Delays the subscription to the main source until the other
observable fires an event or completes.
Breaks the links between the upstream and the downstream (the Disposable and
the Observer references) when the sequence terminates or gets disposed.
Calls a consumer after pushing the current item to the downstream.
Execute an action after an onError, onComplete or a dispose event.
Abstraction over an RxJava
Observer that allows associating
a resource with it.Signals the first element of the source via the underlying CompletableFuture,
signals the a default item if the upstream is empty or signals
NoSuchElementException.Maps a sequence of values into CompletableSources and awaits their termination.
Maps a sequence of values into CompletableSources and awaits their termination.
Maps upstream values into MaybeSources and merges their signals into one sequence.
Maps upstream values into SingleSources and merges their signals into one sequence.
Maps the upstream values onto
Streams and emits their items in order to the downstream.Maps a sequence into an Iterable and emits its values.
Executes an
Action and signals its exception or completes normally.Calls a Callable and emits its resulting single value or signals its exception.
Wrap a Completable into an Observable.
Wrap a CompletionStage and signal its outcome.
Executes an
Runnable and signals its exception or completes normally.Wraps a
Stream and emits its values as an Observable sequence.Calls a Supplier and emits its resulting single value or signals its exception.
Hides the identity of the wrapped ObservableSource and its Disposable.
Helper utility class to support Observable with inner classes.
Represents a constant scalar value.
Consumes the source ObservableSource and emits its last item, the defaultItem
if empty or a NoSuchElementException if even the defaultItem is null.
Consumes the source ObservableSource and emits its last item, the defaultItem
if empty or a NoSuchElementException if even the defaultItem is null.
Signals the last element of the source via the underlying CompletableFuture,
signals the a default item if the upstream is empty or signals
NoSuchElementException.Allows lifting operators into a chain of Observables.
Map the upstream values into an Optional and emit its value if any.
Merges an Observable and a Completable by emitting the items of the Observable and waiting until
both the Observable and Completable complete normally.
Merges an Observable and a Maybe by emitting the items of the Observable and the success
value of the Maybe and waiting until both the Observable and Maybe terminate normally.
Merges an Observable and a Single by emitting the items of the Observable and the success
value of the Single and waiting until both the Observable and Single terminate normally.
Emits an onComplete if the source emits an onError and the predicate returns true for
that Throwable.
A functional interface that has a
subscribe() method that receives
an ObservableEmitter instance that allows pushing
events in a cancellation-safe manner.Interface to map/wrap a downstream
Observer to an upstream Observer.Shares a single underlying connection to the upstream ObservableSource
and multicasts events to all subscribed observers until the upstream
completes or the connection is disposed.
Intercepts the dispose signal from the downstream and
removes itself from the connection's observers array
at most once.
Shares a source Observable for the duration of a selector function.
Emits a range of integer values from start to end.
Reduce a sequence of values into a single value via an aggregator function and emit the final value or complete
if the source is empty.
Reduce a sequence of values, starting from a seed value and by using
an accumulator function and return the last accumulated value.
Reduce a sequence of values, starting from a generated seed value and by using
an accumulator function and return the last accumulated value.
Returns an observable sequence that stays connected to the source as long as
there is at least one subscription to the observable sequence.
Repeatedly subscribe to a source if a handler ObservableSource signals an item.
Base class for bounded buffering with options to specify an
enter and leave transforms and custom truncation behavior.
A Disposable that manages the disposed state of a
child Observer in thread-safe manner.
Represents a node in a bounded replay buffer's linked list.
The interface for interacting with various buffering logic.
Size and time bound replay buffer.
A bounded replay buffer implementation with size limit only.
Holds an unbounded list of events.
Repeatedly subscribe to a source if a handler ObservableSource signals an item.
Utility classes to work with scalar-sourced XMap operators (where X == { flat, concat, switch }).
Represents a Disposable that signals one onNext followed by an onComplete.
Maps a scalar value to an ObservableSource and subscribes to it.
Signals the only element of the source via the underlying CompletableFuture,
signals the a default item if the upstream is empty or signals
IllegalArgumentException
if the upstream has more than one item.Represents a basic, non-backpressured
Observable source base interface,
consumable via an Observer.Base class that extends CompletableFuture and provides basic infrastructure
to notify watchers upon upstream signals.
Maps the upstream values into
CompletableSources, subscribes to the newer one while
disposing the subscription to the previous CompletableSource, thus keeping at most one
active CompletableSource running.Maps the upstream items into
MaybeSources and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value if available, optionally delaying
errors from the main source or the inner sources.Maps the upstream items into
SingleSources and switches (subscribes) to the newer ones
while disposing the older ones and emits the latest success value if available, optionally delaying
errors from the main source or the inner sources.Emits the next or latest item when the given time elapses.
Interface to compose
Observables.Wrapper for a Subject that detects an incoming subscriber.
Combines a main sequence of values with the latest from multiple other sequences via
a selector function.
Provides a mechanism for receiving push-based notifications.
Represents an exception used to signal to the
RxJavaPlugins.onError() that a
callback-based subscribe() method on a base reactive type didn't specify
an onError handler.A simple open hash set with add, remove and clear capabilities only.
Reduce the sequence of values in each 'rail' to a single value.
Reduces all 'rails' into a single via a Java 8
Collector callback set.Concatenates the generated Publishers on each rail.
Calls a Consumer for each upstream value passing by
and handles any failure with a handler function.
Enumerations for handling failure within a parallel operator.
Filters each 'rail' of the source ParallelFlowable with a predicate function.
Filters each 'rail' of the source ParallelFlowable with a predicate function.
Flattens the generated Publishers on each rail.
Flattens the generated
Iterables on each rail.Flattens the generated
Streams on each rail.Abstract base class for parallel publishing of events signaled to an array of
Subscribers.Convenience interface and callback used by the
ParallelFlowable.to(io.reactivex.rxjava3.parallel.ParallelFlowableConverter<T, R>) operator to turn a ParallelFlowable into
another value fluently.Wraps multiple Publishers into a ParallelFlowable which runs them
in parallel.
Dispatches the values from upstream in a round robin fashion to subscribers which are
ready to consume elements.
Merges the individual 'rails' of the source ParallelFlowable, unordered,
into a single regular Publisher sequence (exposed as Flowable).
Maps each 'rail' of the source ParallelFlowable with a mapper function.
Maps each 'rail' of the source ParallelFlowable with a mapper function.
Maps each 'rail' of the source ParallelFlowable with a mapper function
and handle any failure based on a handler function.
Maps each 'rail' of the source ParallelFlowable with a mapper function
and handle any failure based on a handler function.
Execute a Consumer in each 'rail' for the current element passing through.
Reduce the sequence of values in each 'rail' to a single value.
Reduces all 'rails' into a single value which then gets reduced into a single
Publisher sequence.
Ensures each 'rail' from upstream runs on a Worker from a Scheduler.
Given sorted rail sequences (according to the provided comparator) as List
emit the smallest item from these parallel Lists to the Subscriber.
Interface to compose ParallelFlowable.
A functional interface (callback) that returns true or false for the given input value.
Explicitly named exception to indicate a Reactive-Streams
protocol violation.
Processor that multicasts all subsequently observed items to its current
Subscribers.Wraps the actual subscriber, tracks its requests and makes cancellation
to remove itself from the current subscribers array.
A Subject that emits (multicasts) items to currently subscribed
Observers and terminal events to current
or late Observers.Wraps the actual subscriber, tracks its requests and makes cancellation
to remove itself from the current subscribers array.
An interface extending
SimpleQueue and Disposable and allows negotiating
the fusion mode between subsequent operators of the Observable base reactive type.Utility class to help with the queue-drain serialization idiom.
Abstract base class for subscribers that hold another subscriber, a queue
and requires queue-drain behavior.
Abstract base class for subscribers that hold another subscriber, a queue
and requires queue-drain behavior.
Pads the header away from other fields.
Pads the header away from other fields.
Pads away the wip from the other fields.
Pads away the wip from the other fields.
Contains the requested field.
Pads away the requested from the other fields.
The wip counter.
The WIP counter.
Represents a
SimpleQueue plus the means and constants for requesting a fusion mode.Indicates an overflow happened because the upstream disregarded backpressure completely or
Subscriber.onNext(Object) was called concurrently from multiple threads
without synchronization.An interface extending
SimpleQueue and Subscription and allows negotiating
the fusion mode between subsequent operators of the Flowable base reactive type.Base class for Disposable containers that manage some other type that
has to be run when the container is disposed.
Replays events to Subscribers.
Abstraction over a buffer that receives events and replays them to
individual Subscribers.
Replays events (in a configurable bounded or unbounded manner) to current and late
Observers.Abstraction over a buffer that receives events and replays them to
individual Observers.
An abstract
CompletableObserver that allows asynchronous cancellation of its subscription and associated resources.An abstract
MaybeObserver that allows asynchronous cancellation of its subscription and associated resources.An abstract
Observer that allows asynchronous cancellation of its subscription and associated resources.An abstract
SingleObserver that allows asynchronous cancellation of its subscription
and the associated resources.An abstract Subscriber that allows asynchronous cancellation of its
subscription and associated resources.
A SingleObserver implementation used for subscribing to the actual SingleSource
and replace the current Disposable in a parent AtomicReference.
A disposable container that manages a
Runnable instance.Utility class to inject handlers to certain standard RxJava operations.
A ThreadFactory that counts how many threads have been created and given a prefix,
sets the created Thread's name to
prefix-count.Wraps another
CompletableObserver and catches exceptions thrown by its
onSubscribe, onError or
onComplete methods despite the protocol forbids it.Wraps another
MaybeObserver and catches exceptions thrown by its
onSubscribe, onSuccess, onError or
onComplete methods despite the protocol forbids it.Wraps another
Observer and ensures all onXXX methods conform the protocol
(except the requirement for serialized access).Wraps another
SingleObserver and catches exceptions thrown by its
onSubscribe, onSuccess or onError methods despite
the protocol forbids it.Wraps another
Subscriber and ensures all onXXX methods conform the protocol
(except the requirement for serialized access).A Subscription that holds a constant value and emits it only when requested.
A marker interface indicating that a scalar, constant value
is held by the implementing reactive type which can be
safely extracted during assembly time can be used for
optimization.
Utility class to extract a value from a scalar source reactive type,
map it to a 0-1 type then subscribe the output type's consumer to it,
saving on the overhead of the regular subscription channel.
A Callable to be submitted to an ExecutorService that runs a Runnable
action periodically and manages completion/cancellation.
A Callable to be submitted to an ExecutorService that runs a Runnable
action and manages completion/cancellation.
A
Scheduler is an object that specifies an API for scheduling
units of work provided in the form of Runnables 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 executing
Runnable tasks on
an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system).Allows retrieving multiple workers from the implementing
Scheduler in a way that when asking for
at most the parallelism level of the Scheduler, those
Scheduler.Worker instances will be running
with different backing threads.The callback interface for the
SchedulerMultiWorkerSupport.createWorkers(int, WorkerCallback)
method.Manages the creating of ScheduledExecutorServices and sets up purging.
Interface to indicate the implementor class wraps a
Runnable that can
be accessed via SchedulerRunnableIntrospection.getWrappedRunnable().Static factory methods for returning standard
Scheduler instances.Indicates what kind of scheduler the class or method uses.
Allows the use of operators for controlling the timing around when actions
scheduled on workers are actually done.
A Disposable container that allows updating/replacing a Disposable
atomically and with respect of disposing the container itself.
A Disposable container that allows atomically updating/replacing the contained
Disposable with another Disposable, disposing the old one when updating plus
handling the disposition when the container itself is disposed.
Serializes access to the
Observer.onNext(Object), Observer.onError(Throwable) and
Observer.onComplete() methods of another Observer.Serializes calls to the Subscriber methods.
Serializes calls to the Observer methods.
Serializes access to the
Subscriber.onNext(Object), Subscriber.onError(Throwable) and
Subscriber.onComplete() methods of another Subscriber.A simplified interface for offering, polling and clearing a queue.
The
Single class implements the Reactive Pattern for a single value response.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.Maps the success value of the source to a Notification, then
maps it back to the corresponding signal type.
Breaks the references between the upstream and downstream when the Maybe terminates.
Calls a consumer after pushing the current item to the downstream.
Calls an action after pushing the current item or an error to the downstream.
Execute an action after an onSuccess, onError or a dispose event.
Invokes callbacks upon
onSubscribe from upstream and
dispose from downstream.Calls a callback when the upstream calls onSubscribe with a disposable.
Abstraction over an RxJava
SingleObserver that allows associating
a resource with it.Maps a source item to another SingleSource then calls a BiFunction with the
original item and the secondary item to generate the final result.
Maps the success value of the source SingleSource into a Completable.
Maps a success value into an Iterable and streams it back as a Flowable.
Maps a success value into an Iterable and streams it back as an Observable.
Maps a value into a SingleSource and relays its signal.
Maps the success value of a Single onto an ObservableSource and
relays its signals to the downstream observer.
A Flowable that emits items based on applying a specified function to the item emitted by the
source Single, where that function returns a Publisher.
Map the success value into a Java
Stream and emits its values.Map the success value into a Java
Stream and emits its values.Wrap a CompletionStage and signal its outcome.
Calls a supplier and emits its value or exception to the incoming SingleObserver.
Helper utility class to support Single with inner classes.
Maps the success value to an
Optional and emits its non-empty value or completes.Turn the signal types of a Single source into a single Notification of
equal kind.
Provides a mechanism for receiving push-based notification of a single value or an error.
Emits an onComplete if the source emits an onError and the predicate returns true for
that Throwable.
A functional interface that has a
subscribe() method that receives
a SingleEmitter instance that allows pushing
an event in a cancellation-safe manner.Interface to map/wrap a downstream
SingleObserver to an upstream SingleObserver.Relays signals from upstream according to downstream requests and allows
signalling a final value followed by onComplete in a backpressure-aware manner.
A scheduler with a shared, single threaded underlying ScheduledExecutorService.
Represents a basic
Single source base interface,
consumable via an SingleObserver.Represents a hot Single-like source and consumer of events similar to Subjects.
Signals the events of the source Single or signals a CancellationException if the
other Publisher signalled first.
Measures the time between subscription and the success item emission
from the upstream and emits this as a
Timed success value.Signals a
0L after the specified delay.Wraps a Single and exposes it as a Flowable.
Wraps a Single and exposes it as an Observable.
Interface to compose
Singles.Makes sure a dispose() call from downstream happens on the specified scheduler.
A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.
A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower
than the producer.
Ensures that the event flow between the upstream and downstream follow
the Reactive-Streams 1.0 specification by honoring the 3 additional rules
(which are omitted in standard operators due to performance reasons).
Represents an
Observer and an Observable at the same time, allowing
multicasting events from a single source to multiple child Observers.Arbitrates requests and cancellation between Subscriptions.
A Disposable container that handles a
Subscription.Utility methods to validate Subscriptions in the various onSubscribe calls.
A functional interface (callback) that provides a single value or
throws an exception.
Suppress errors by the AnimalSniffer plugin.
An
Observer, MaybeObserver, SingleObserver and
CompletableObserver composite that can record events from
Observables, Maybes, Singles and Completables
and allows making assertions about them.An observer that ignores all events and does not report errors.
A special, non thread-safe scheduler for testing operators that require
a scheduler without introducing real concurrency and allows manually advancing
a virtual time.
A
Subscriber implementation that records events and allows making assertions about them.A subscriber that ignores all events and does not report errors.
Holds onto a value along with time information.
Schedules work on the current thread but does not execute immediately.
Wrapper for Throwable errors that are sent to
RxJavaPlugins.onError.A
FlowableProcessor variant that queues up events until a single Subscriber subscribes to it, replays
those events to it until the Subscriber catches up and then switches to relaying events live to
this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels
its subscription.A Subject that queues up events until a single
Observer subscribes to it, replays
those events to it until the Observer catches up and then switches to relaying events live to
this single Observer until this UnicastSubject terminates or the Observer disposes.Tracks the current underlying array size in a volatile field.