A B C D E F G H I J L M N O P Q R S T U V W Z

A

accept(T1, T2) - Method in interface io.reactivex.rxjava3.functions.BiConsumer

Performs an operation on the given values.

accept(T) - Method in interface io.reactivex.rxjava3.functions.Consumer

Consume the given value.

accept(long) - Method in interface io.reactivex.rxjava3.functions.LongConsumer

Consume a primitive long input.

Action - Interface in io.reactivex.rxjava3.functions

A functional interface similar to Runnable but allows throwing a checked exception.

add(Disposable) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

Adds a Disposable to this container or disposes it if the container has been disposed.

add(Disposable) - Method in interface io.reactivex.rxjava3.disposables.DisposableContainer

Adds a disposable to this container or disposes it if the container has been disposed.

add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver

Adds a resource to this ResourceCompletableObserver.

add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver

Adds a resource to this ResourceMaybeObserver.

add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceObserver

Adds a resource to this ResourceObserver.

add(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver

Adds a resource to this ResourceSingleObserver.

add(Disposable) - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber

Adds a resource to this ResourceSubscriber.

addAll(Disposable...) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

Atomically adds the given array of Disposables to the container or disposes them all if the container has been disposed.

advanceTimeBy(long, TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.TestScheduler

Moves the Scheduler's clock forward by a specified amount of time.

advanceTimeTo(long, TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.TestScheduler

Moves the Scheduler's clock to a particular moment in time.

all(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current Flowable satisfy a condition.

all(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a Boolean that indicates whether all of the items emitted by the current Observable satisfy a condition.

amb(Iterable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which terminates as soon as one of the source Completables in the Iterable sequence terminates (normally or with an error) and disposes all other Completables.

amb(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Mirrors the one Publisher in an Iterable of several Publishers that first either emits an item or sends a termination notification.

amb(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Runs multiple MaybeSources provided by an Iterable sequence and signals the events of the first one that signals (disposing the rest).

amb(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends a termination notification.

amb(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).

ambArray(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.

ambArray(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Mirrors the one Publisher in an array of several Publishers that first either emits an item or sends a termination notification.

ambArray(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Runs multiple MaybeSources and signals the events of the first one that signals (disposing the rest).

ambArray(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Mirrors the one ObservableSource in an array of several ObservableSources that first either emits an item or sends a termination notification.

ambArray(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Runs multiple SingleSources and signals the events of the first one that signals (disposing the rest).

ambWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that emits the a terminated event of either this Completable or the other CompletableSource, whichever fires first.

ambWith(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Mirrors the Publisher (current or provided) that first either emits an item or sends a termination notification.

ambWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Mirrors the MaybeSource (current or provided) that first signals an event.

ambWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Mirrors the current Observable or the other ObservableSource provided of which the first either emits an item or sends a termination notification.

ambWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Signals the event of this or the other SingleSource whichever signals first.

andThen(ObservableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns an Observable which will subscribe to this Completable and once that is completed then will subscribe to the next ObservableSource.

andThen(Publisher) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to the next Publisher.

andThen(SingleSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the next SingleSource.

andThen(MaybeSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Maybe which will subscribe to this Completable and once that is completed then will subscribe to the next MaybeSource.

andThen(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that first runs this Completable and then the other CompletableSource.

any(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits true if any item emitted by the current Flowable satisfies a specified condition, otherwise false.

any(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits true if any item emitted by the current Observable satisfies a specified condition, otherwise false.

ANY - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable

Request any of the QueueFuseable.SYNC or QueueFuseable.ASYNC modes.

apply(Completable) - Method in interface io.reactivex.rxjava3.core.CompletableConverter

Applies a function to the upstream Completable and returns a converted value of type R.

apply(CompletableObserver) - Method in interface io.reactivex.rxjava3.core.CompletableOperator

Applies a function to the child CompletableObserver and returns a new parent CompletableObserver.

apply(Completable) - Method in interface io.reactivex.rxjava3.core.CompletableTransformer

Applies a function to the upstream Completable and returns a CompletableSource.

apply(Flowable) - Method in interface io.reactivex.rxjava3.core.FlowableConverter

Applies a function to the upstream Flowable and returns a converted value of type R.

apply(Subscriber) - Method in interface io.reactivex.rxjava3.core.FlowableOperator

Applies a function to the child Subscriber and returns a new parent Subscriber.

apply(Flowable) - Method in interface io.reactivex.rxjava3.core.FlowableTransformer

Applies a function to the upstream Flowable and returns a Publisher with optionally different element type.

apply(Maybe) - Method in interface io.reactivex.rxjava3.core.MaybeConverter

Applies a function to the upstream Maybe and returns a converted value of type R.

apply(MaybeObserver) - Method in interface io.reactivex.rxjava3.core.MaybeOperator

Applies a function to the child MaybeObserver and returns a new parent MaybeObserver.

apply(Maybe) - Method in interface io.reactivex.rxjava3.core.MaybeTransformer

Applies a function to the upstream Maybe and returns a MaybeSource with optionally different element type.

apply(Observable) - Method in interface io.reactivex.rxjava3.core.ObservableConverter

Applies a function to the upstream Observable and returns a converted value of type R.

apply(Observer) - Method in interface io.reactivex.rxjava3.core.ObservableOperator

Applies a function to the child Observer and returns a new parent Observer.

apply(Observable) - Method in interface io.reactivex.rxjava3.core.ObservableTransformer

Applies a function to the upstream Observable and returns an ObservableSource with optionally different element type.

apply(Single) - Method in interface io.reactivex.rxjava3.core.SingleConverter

Applies a function to the upstream Single and returns a converted value of type R.

apply(SingleObserver) - Method in interface io.reactivex.rxjava3.core.SingleOperator

Applies a function to the child SingleObserver and returns a new parent SingleObserver.

apply(Single) - Method in interface io.reactivex.rxjava3.core.SingleTransformer

Applies a function to the upstream Single and returns a SingleSource with optionally different element type.

apply(T1, T2) - Method in interface io.reactivex.rxjava3.functions.BiFunction

Calculate a value based on the input values.

apply(T) - Method in interface io.reactivex.rxjava3.functions.Function

Apply some calculation to the input value and return some other value.

apply(T1, T2, T3) - Method in interface io.reactivex.rxjava3.functions.Function3

Calculate a value based on the input values.

apply(T1, T2, T3, T4) - Method in interface io.reactivex.rxjava3.functions.Function4

Calculate a value based on the input values.

apply(T1, T2, T3, T4, T5) - Method in interface io.reactivex.rxjava3.functions.Function5

Calculate a value based on the input values.

apply(T1, T2, T3, T4, T5, T6) - Method in interface io.reactivex.rxjava3.functions.Function6

Calculate a value based on the input values.

apply(T1, T2, T3, T4, T5, T6, T7) - Method in interface io.reactivex.rxjava3.functions.Function7

Calculate a value based on the input values.

apply(T1, T2, T3, T4, T5, T6, T7, T8) - Method in interface io.reactivex.rxjava3.functions.Function8

Calculate a value based on the input values.

apply(T1, T2, T3, T4, T5, T6, T7, T8, T9) - Method in interface io.reactivex.rxjava3.functions.Function9

Calculate a value based on the input values.

apply(int) - Method in interface io.reactivex.rxjava3.functions.IntFunction

Calculates a value based on a primitive integer input.

apply(Long, Throwable) - Method in enum io.reactivex.rxjava3.parallel.ParallelFailureHandling

apply(ParallelFlowable) - Method in interface io.reactivex.rxjava3.parallel.ParallelFlowableConverter

Applies a function to the upstream ParallelFlowable and returns a converted value of type R.

apply(ParallelFlowable) - Method in interface io.reactivex.rxjava3.parallel.ParallelTransformer

Applies a function to the upstream ParallelFlowable and returns a ParallelFlowable with optionally different element type.

assertComplete() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber received exactly one onComplete event.

assertEmpty() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the TestObserver/TestSubscriber has received a Disposable/Subscription via onSubscribe but no other events.

assertError(Throwable) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber received exactly the specified onError event value.

assertError(Class) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Asserts that this TestObserver/TestSubscriber received exactly one onError event which is an instance of the specified errorClass Class.

assertError(Predicate) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Asserts that this TestObserver/TestSubscriber received exactly one onError event for which the provided predicate returns true.

assertFailure(Class, T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the upstream signaled the specified values in order and then failed with a specific class or subclass of Throwable.

assertNoErrors() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber has not received an onError event.

assertNotComplete() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber has not received an onComplete event.

assertNoValues() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber has not received any onNext events.

assertResult(T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the upstream signaled the specified values in order and completed normally.

assertSubscribed() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the onSubscribe method was called exactly once.

assertSubscribed() - Method in class io.reactivex.rxjava3.observers.TestObserver

Assert that the TestObserver.onSubscribe(Disposable) method was called exactly once.

assertSubscribed() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Assert that the TestSubscriber.onSubscribe(Subscription) method was called exactly once.

assertValue(T) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber received exactly one onNext value which is equal to the given value with respect to Objects.equals(Object, Object).

assertValue(Predicate) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Asserts that this TestObserver/TestSubscriber received exactly one onNext value for which the provided predicate returns true.

assertValueAt(int, T) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Asserts that this TestObserver/TestSubscriber received an onNext value at the given index which is equal to the given value with respect to null-safe Objects.equals(Object, Object).

assertValueAt(int, Predicate) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Asserts that this TestObserver/TestSubscriber received an onNext value at the given index for the provided predicate returns true.

assertValueCount(int) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that this TestObserver/TestSubscriber received the specified number onNext events.

assertValues(T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the TestObserver/TestSubscriber received only the specified values in the specified order.

assertValueSequence(Iterable) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the TestObserver/TestSubscriber received only the specified sequence of values in the same order.

assertValuesOnly(T...) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating.

ASYNC - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable

Request an asynchronous fusion mode and can be returned by QueueFuseable.requestFusion(int) for an accepted mode.

AsyncProcessor<T> - Class in io.reactivex.rxjava3.processors

Processor that emits the very last value followed by a completion event or the received error to Subscribers.

AsyncSubject<T> - Class in io.reactivex.rxjava3.subjects

A Subject that emits the very last value followed by a completion event or the received error to Observers.

autoConnect() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the first Subscriber subscribes.

autoConnect(int) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it.

autoConnect(int, Consumer) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Returns a Flowable that automatically connects (at most once) to this ConnectableFlowable when the specified number of Subscribers subscribe to it and calls the specified callback with the Disposable associated with the established connection.

autoConnect() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Returns an Observable that automatically connects (at most once) to this ConnectableObservable when the first Observer subscribes.

autoConnect(int) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Returns an Observable that automatically connects (at most once) to this ConnectableObservable when the specified number of Observers subscribe to it.

autoConnect(int, Consumer) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Returns an Observable that automatically connects (at most once) to this ConnectableObservable when the specified number of Observers subscribe to it and calls the specified callback with the Disposable associated with the established connection.

await() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Awaits until this TestObserver/TestSubscriber receives an onError or onComplete events.

await(long, TimeUnit) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Awaits the specified amount of time or until this TestObserver/TestSubscriber receives an onError or onComplete events, whichever happens first.

awaitCount(int) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Await until the TestObserver/TestSubscriber receives the given number of items or terminates by sleeping 10 milliseconds at a time up to 5000 milliseconds of timeout.

awaitDone(long, TimeUnit) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Awaits until the internal latch is counted down.

B

BackpressureKind - Enum in io.reactivex.rxjava3.annotations

Enumeration for various kinds of backpressure support.

BackpressureOverflowStrategy - Enum in io.reactivex.rxjava3.core

Options to deal with buffer overflow when using onBackpressureBuffer.

BackpressureStrategy - Enum in io.reactivex.rxjava3.core

Represents the options for applying backpressure to a source sequence.

BackpressureSupport - Annotation Type in io.reactivex.rxjava3.annotations

Indicates the backpressure support kind of the associated operator or class.

BaseTestConsumer<T,U extends BaseTestConsumer<T,U>> - Class in io.reactivex.rxjava3.observers

Base class with shared infrastructure to support TestSubscriber and TestObserver.

BaseTestConsumer() - Constructor for class io.reactivex.rxjava3.observers.BaseTestConsumer

Constructs a BaseTestConsumer with CountDownLatch set to 1.

BehaviorProcessor<T> - Class in io.reactivex.rxjava3.processors

Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed Subscriber.

BehaviorSubject<T> - Class in io.reactivex.rxjava3.subjects

Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.

Beta - Annotation Type in io.reactivex.rxjava3.annotations

Indicates the feature is in beta state: it will be most likely stay but the signature may change between versions without warning.

BiConsumer<T1,T2> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that accepts two values (of possibly different types).

BiFunction<T1,T2,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

BiPredicate<T1,T2> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that returns true or false for the given input values.

blockingAwait() - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.

blockingAwait(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to and awaits the termination of this Completable instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.

blockingFirst() - Method in class io.reactivex.rxjava3.core.Flowable

Returns the first item emitted by this Flowable, or throws NoSuchElementException if it emits no items.

blockingFirst(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns the first item emitted by this Flowable, or a default value if it emits no items.

blockingFirst() - Method in class io.reactivex.rxjava3.core.Observable

Returns the first item emitted by the current Observable, or throws NoSuchElementException if it emits no items.

blockingFirst(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns the first item emitted by the current Observable, or a default value if it emits no items.

blockingForEach(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Consumes the current Flowable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

blockingForEach(Consumer, int) - Method in class io.reactivex.rxjava3.core.Flowable

Consumes the current Flowable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

blockingForEach(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Consumes the current Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

blockingForEach(Consumer, int) - Method in class io.reactivex.rxjava3.core.Observable

Consumes the current Observable in a blocking fashion and invokes the given Consumer with each upstream item on the current thread until the upstream terminates.

blockingGet() - Method in class io.reactivex.rxjava3.core.Maybe

Waits in a blocking fashion until the current Maybe signals a success value (which is returned), null if completed or an exception (which is propagated).

blockingGet(T) - Method in class io.reactivex.rxjava3.core.Maybe

Waits in a blocking fashion until the current Maybe signals a success value (which is returned), defaultValue if completed or an exception (which is propagated).

blockingGet() - Method in class io.reactivex.rxjava3.core.Single

Waits in a blocking fashion until the current Single signals a success value (which is returned) or an exception (which is propagated).

blockingIterable() - Method in class io.reactivex.rxjava3.core.Flowable

Converts this Flowable into an Iterable.

blockingIterable(int) - Method in class io.reactivex.rxjava3.core.Flowable

Converts this Flowable into an Iterable.

blockingIterable() - Method in class io.reactivex.rxjava3.core.Observable

Exposes the current Observable as an Iterable which, when iterated, subscribes to the current Observable and blocks until the current Observable emits items or terminates.

blockingIterable(int) - Method in class io.reactivex.rxjava3.core.Observable

Exposes the current Observable as an Iterable which, when iterated, subscribes to the current Observable and blocks until the current Observable emits items or terminates.

blockingLast() - Method in class io.reactivex.rxjava3.core.Flowable

Returns the last item emitted by this Flowable, or throws NoSuchElementException if this Flowable emits no items.

blockingLast(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns the last item emitted by this Flowable, or a default value if it emits no items.

blockingLast() - Method in class io.reactivex.rxjava3.core.Observable

Returns the last item emitted by the current Observable, or throws NoSuchElementException if the current Observable emits no items.

blockingLast(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns the last item emitted by the current Observable, or a default value if it emits no items.

blockingLatest() - Method in class io.reactivex.rxjava3.core.Flowable

Returns an Iterable that returns the latest item emitted by this Flowable, waiting if necessary for one to become available.

blockingLatest() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Iterable that returns the latest item emitted by the current Observable, waiting if necessary for one to become available.

blockingMostRecent(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns an Iterable that always returns the item most recently emitted by this Flowable.

blockingMostRecent(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Iterable that always returns the item most recently emitted by the current Observable.

blockingNext() - Method in class io.reactivex.rxjava3.core.Flowable

Returns an Iterable that blocks until this Flowable emits another item, then returns that item.

blockingNext() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Iterable that blocks until the current Observable emits another item, then returns that item.

blockingSingle() - Method in class io.reactivex.rxjava3.core.Flowable

If this Flowable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.

blockingSingle(T) - Method in class io.reactivex.rxjava3.core.Flowable

If this Flowable completes after emitting a single item, return that item; if it emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value.

blockingSingle() - Method in class io.reactivex.rxjava3.core.Observable

If the current Observable completes after emitting a single item, return that item, otherwise throw a NoSuchElementException.

blockingSingle(T) - Method in class io.reactivex.rxjava3.core.Observable

If the current Observable completes after emitting a single item, return that item; if it emits more than one item, throw an IllegalArgumentException; if it emits no items, return a default value.

blockingStream() - Method in class io.reactivex.rxjava3.core.Flowable

Creates a sequential Stream to consume or process this Flowable in a blocking manner via the Java Stream API.

blockingStream(int) - Method in class io.reactivex.rxjava3.core.Flowable

Creates a sequential Stream to consume or process this Flowable in a blocking manner via the Java Stream API.

blockingStream() - Method in class io.reactivex.rxjava3.core.Observable

Creates a sequential Stream to consume or process the current Observable in a blocking manner via the Java Stream API.

blockingStream(int) - Method in class io.reactivex.rxjava3.core.Observable

Creates a sequential Stream to consume or process the current Observable in a blocking manner via the Java Stream API.

blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to the current Completable and blocks the current thread until it terminates.

blockingSubscribe(Action) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to the current Completable and calls given onComplete callback on the current thread when it completes normally.

blockingSubscribe(Action, Consumer) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to the current Completable and calls the appropriate callback on the current thread when it terminates.

blockingSubscribe(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to the current Completable and calls the appropriate CompletableObserver method on the current thread.

blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Flowable

Runs the current Flowable to a terminal event, ignoring any values and rethrowing any exception.

blockingSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, int) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, Consumer, int) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, Consumer, Action, int) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Subscriber) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the source and calls the Subscriber methods on the current thread.

blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to the current Maybe and blocks the current thread until it terminates.

blockingSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to the current Maybe and calls given onSuccess callback on the current thread when it completes normally.

blockingSubscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.

blockingSubscribe(Consumer, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.

blockingSubscribe(MaybeObserver) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to the current Maybe and calls the appropriate MaybeObserver method on the current thread.

blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Observable

Runs the current Observable to a terminal event, ignoring any values and rethrowing any exception.

blockingSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Consumer, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the source and calls the given callbacks on the current thread.

blockingSubscribe(Observer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the source and calls the Observer methods on the current thread.

blockingSubscribe() - Method in class io.reactivex.rxjava3.core.Single

Subscribes to the current Single and blocks the current thread until it terminates.

blockingSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Single

Subscribes to the current Single and calls given onSuccess callback on the current thread when it completes normally.

blockingSubscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Single

Subscribes to the current Single and calls the appropriate callback on the current thread when it terminates.

blockingSubscribe(SingleObserver) - Method in class io.reactivex.rxjava3.core.Single

Subscribes to the current Single and calls the appropriate SingleObserver method on the current thread.

BooleanSupplier - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that returns a boolean value.

BOUNDARY - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable

Used in binary or combination with the other constants as an input to QueueFuseable.requestFusion(int) indicating that the SimpleQueue.poll() will be called behind an asynchronous boundary and thus may change the non-trivial computation locations attached to the SimpleQueue.poll() chain of fused operators.

buffer(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(int, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(int, int, Supplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(int, Supplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, long, TimeUnit, Scheduler, Supplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, TimeUnit, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, TimeUnit, Scheduler, int, Supplier, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(Publisher, Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(Publisher, Function>, Supplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits buffers of items it collects from the current Flowable.

buffer(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the specified boundary Publisher emits an item.

buffer(Publisher, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the specified boundary Publisher emits an item.

buffer(Publisher, Supplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits non-overlapping buffered items from the current Flowable each time the specified boundary Publisher emits an item.

buffer(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(int, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(int, int, Supplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(int, Supplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, long, TimeUnit, Scheduler, Supplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, TimeUnit, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, TimeUnit, Scheduler, int, Supplier, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(ObservableSource, Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(ObservableSource, Function>, Supplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits buffers of items it collects from the current Observable.

buffer(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.

buffer(ObservableSource, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.

buffer(ObservableSource, Supplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits non-overlapping buffered items from the current Observable each time the specified boundary ObservableSource emits an item.

bufferSize() - Static method in class io.reactivex.rxjava3.core.Flowable

Returns the default internal buffer size used by most async operators.

bufferSize() - Static method in class io.reactivex.rxjava3.core.Observable

Returns the default 'island' size or capacity-increment hint for unbounded buffers.

C

cache() - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to this Completable only once, when the first CompletableObserver subscribes to the result Completable, caches its terminal event and relays/replays it to observers.

cache() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.

cache() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that subscribes to this Maybe lazily, caches its event and replays it, to all the downstream subscribers.

cache() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that subscribes to the current Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.

cache() - Method in class io.reactivex.rxjava3.core.Single

Stores the success value or exception from the current Single and replays it to late SingleObservers.

cacheWithInitialCapacity(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that subscribes to this Publisher lazily, caches all of its events and replays them, in the same order as received, to all the downstream subscribers.

cacheWithInitialCapacity(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that subscribes to the current Observable lazily, caches all of its events and replays them, in the same order as received, to all the downstream observers.

cancel() - Method in interface io.reactivex.rxjava3.functions.Cancellable

Cancel the action or free a resource.

cancel() - Method in class io.reactivex.rxjava3.observers.DefaultObserver

Cancels the upstream's disposable.

cancel() - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber

Cancels the upstream's Subscription.

cancel() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber

Cancels the Subscription set via DisposableSubscriber.onSubscribe(Subscription) or makes sure a Subscription set asynchronously (later) is cancelled immediately.

cancel() - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber

cancel() - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber

cancel() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Cancellable - Interface in io.reactivex.rxjava3.functions

A functional interface that has a single cancel method that can throw.

cast(Class) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the upstream items while they can be cast via Class.cast(Object) until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in a ClassCastException to be signaled to the downstream.

cast(Class) - Method in class io.reactivex.rxjava3.core.Maybe

Casts the success value of the current Maybe into the target type or signals a ClassCastException if not compatible.

cast(Class) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the upstream items while they can be cast via Class.cast(Object) until the upstream terminates, or until the upstream signals an item which can't be cast, resulting in a ClassCastException to be signaled to the downstream.

cast(Class) - Method in class io.reactivex.rxjava3.core.Single

Casts the success value of the current Single into the target type or signals a ClassCastException if not compatible.

CheckReturnValue - Annotation Type in io.reactivex.rxjava3.annotations

Marks methods whose return values should be checked.

checkSubscriptionOnce - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

cleanupBuffer() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

Makes sure the item cached by the head node in a bounded ReplayProcessor is released (as it is never part of a replay).

cleanupBuffer() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

Makes sure the item cached by the head node in a bounded ReplaySubject is released (as it is never part of a replay).

clear() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

Atomically clears the container, then disposes all the previously contained Disposables.

clear() - Method in interface io.reactivex.rxjava3.operators.SimpleQueue

Removes all enqueued items from this queue.

clear() - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue

clear() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

clockDriftTolerance() - Static method in class io.reactivex.rxjava3.core.Scheduler

Returns the clock drift tolerance in nanoseconds.

collect(Supplier, BiConsumer) - Method in class io.reactivex.rxjava3.core.Flowable

Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.

collect(Collector) - Method in class io.reactivex.rxjava3.core.Flowable

Collects the finite upstream's values into a container via a Stream Collector callback set and emits it as the success result.

collect(Supplier, BiConsumer) - Method in class io.reactivex.rxjava3.core.Observable

Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.

collect(Collector) - Method in class io.reactivex.rxjava3.core.Observable

Collects the finite upstream's values into a container via a Stream Collector callback set and emits it as the success result as a Single.

collect(Supplier, BiConsumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Collect the elements in each rail into a collection supplied via a collectionSupplier and collected into with a collector action, emitting the collection at the end.

collect(Collector) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Reduces all values within a 'rail' and across 'rails' with a callbacks of the given Collector into one Flowable containing a single value.

collectInto(U, BiConsumer) - Method in class io.reactivex.rxjava3.core.Flowable

Collects items emitted by the finite source Publisher into a single mutable data structure and returns a Single that emits this structure.

collectInto(U, BiConsumer) - Method in class io.reactivex.rxjava3.core.Observable

Collects items emitted by the finite source Observable into a single mutable data structure and returns a Single that emits this structure.

combineLatest(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Iterable>, Function, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, BiFunction) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines two source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from either of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Function3) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines three source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Publisher, Function4) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines four source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Publisher, Publisher, Function5) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines five source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function6) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines six source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function7) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines seven source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function8) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines eight source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function9) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines nine source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatest(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Observable

Combines a collection of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.

combineLatest(Iterable>, Function, int) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an Iterable of source ObservableSources by emitting an item that aggregates the latest values of each of the returned ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, BiFunction) - Static method in class io.reactivex.rxjava3.core.Observable

Combines two source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from either of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, Function3) - Static method in class io.reactivex.rxjava3.core.Observable

Combines three source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function4) - Static method in class io.reactivex.rxjava3.core.Observable

Combines four source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function5) - Static method in class io.reactivex.rxjava3.core.Observable

Combines five source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function6) - Static method in class io.reactivex.rxjava3.core.Observable

Combines six source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function7) - Static method in class io.reactivex.rxjava3.core.Observable

Combines seven source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function8) - Static method in class io.reactivex.rxjava3.core.Observable

Combines eight source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatest(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function9) - Static method in class io.reactivex.rxjava3.core.Observable

Combines nine source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatestArray(Publisher[], Function) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatestArray(Publisher[], Function, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatestArray(ObservableSource[], Function) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the returned ObservableSources, where this aggregation is defined by a specified function.

combineLatestArray(ObservableSource[], Function, int) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an array of source ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatestArrayDelayError(Publisher[], Function) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function.

combineLatestArrayDelayError(Publisher[], Function, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

combineLatestArrayDelayError(ObservableSource[], Function) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function.

combineLatestArrayDelayError(ObservableSource[], Function, int) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an array of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.

combineLatestDelayError(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

combineLatestDelayError(Iterable>, Function, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Combines a collection of source Publishers by emitting an item that aggregates the latest values of each of the source Publishers each time an item is received from any of the source Publishers, where this aggregation is defined by a specified function and delays any error from the sources until all source Publishers terminate.

combineLatestDelayError(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.

combineLatestDelayError(Iterable>, Function, int) - Static method in class io.reactivex.rxjava3.core.Observable

Combines an Iterable of ObservableSources by emitting an item that aggregates the latest values of each of the ObservableSources each time an item is received from any of the ObservableSources, where this aggregation is defined by a specified function and delays any error from the sources until all source ObservableSources terminate.

Completable - Class in io.reactivex.rxjava3.core

The Completable class represents a deferred computation without any value but only indication for completion or exception.

Completable() - Constructor for class io.reactivex.rxjava3.core.Completable

CompletableConverter<R> - Interface in io.reactivex.rxjava3.core

Convenience interface and callback used by the Completable.to(io.reactivex.rxjava3.core.CompletableConverter) operator to turn a Completable into another value fluently.

CompletableEmitter - Interface in io.reactivex.rxjava3.core

Abstraction over an RxJava CompletableObserver that allows associating a resource with it.

CompletableObserver - Interface in io.reactivex.rxjava3.core

Provides a mechanism for receiving push-based notification of a valueless completion or an error.

CompletableOnSubscribe - Interface in io.reactivex.rxjava3.core

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 in io.reactivex.rxjava3.core

Interface to map/wrap a downstream observer to an upstream observer.

CompletableSource - Interface in io.reactivex.rxjava3.core

Represents a basic Completable source base interface, consumable via an CompletableObserver.

CompletableSubject - Class in io.reactivex.rxjava3.subjects

Represents a hot Completable-like source and consumer of events similar to Subjects.

CompletableTransformer - Interface in io.reactivex.rxjava3.core

Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.

complete() - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that completes immediately when subscribed to.

completions - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

The number of completions.

compose(CompletableTransformer) - Method in class io.reactivex.rxjava3.core.Completable

Calls the given transformer function with this instance and returns the function's resulting CompletableSource wrapped with Completable.wrap(CompletableSource).

compose(FlowableTransformer) - Method in class io.reactivex.rxjava3.core.Flowable

Transform the current Flowable by applying a particular FlowableTransformer function to it.

compose(MaybeTransformer) - Method in class io.reactivex.rxjava3.core.Maybe

Transform a Maybe by applying a particular MaybeTransformer function to it.

compose(ObservableTransformer) - Method in class io.reactivex.rxjava3.core.Observable

Transform the current Observable by applying a particular ObservableTransformer function to it.

compose(SingleTransformer) - Method in class io.reactivex.rxjava3.core.Single

Transform a Single by applying a particular SingleTransformer function to it.

compose(ParallelTransformer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Allows composing operators, in assembly time, on top of this ParallelFlowable and returns another ParallelFlowable with composed features.

CompositeDisposable - Class in io.reactivex.rxjava3.disposables

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.

CompositeDisposable() - Constructor for class io.reactivex.rxjava3.disposables.CompositeDisposable

Creates an empty CompositeDisposable.

CompositeDisposable(Disposable...) - Constructor for class io.reactivex.rxjava3.disposables.CompositeDisposable

Creates a CompositeDisposable with the given array of initial Disposable elements.

CompositeDisposable(Iterable) - Constructor for class io.reactivex.rxjava3.disposables.CompositeDisposable

Creates a CompositeDisposable with the given Iterable sequence of initial Disposable elements.

CompositeException - Exception in io.reactivex.rxjava3.exceptions

Represents an exception that is a composite of one or more other exceptions.

CompositeException(Throwable...) - Constructor for exception io.reactivex.rxjava3.exceptions.CompositeException

Constructs a CompositeException with the given array of Throwables as the list of suppressed exceptions.

CompositeException(Iterable) - Constructor for exception io.reactivex.rxjava3.exceptions.CompositeException

Constructs a CompositeException with the given array of Throwables as the list of suppressed exceptions.

COMPUTATION - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

The operator/class runs on RxJava's computation scheduler or takes timing information from it.

computation() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Returns a default, shared Scheduler instance intended for computational work.

concat(Iterable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concat(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concat(Publisher, int) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concat(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates elements of each Publisher provided via an Iterable sequence into a single sequence of elements without interleaving them.

concat(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.

concat(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by each of the Publishers emitted by the source Publisher, one after the other, without interleaving them.

concat(Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by two Publishers, one after the other, without interleaving them.

concat(Publisher, Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by three Publishers, one after the other, without interleaving them.

concat(Publisher, Publisher, Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by four Publishers, one after the other, without interleaving them.

concat(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by an Iterable sequence as a Flowable sequence.

concat(MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that emits the items emitted by two MaybeSources, one after the other.

concat(MaybeSource, MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that emits the items emitted by three MaybeSources, one after the other.

concat(MaybeSource, MaybeSource, MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that emits the items emitted by four MaybeSources, one after the other.

concat(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence as a Flowable sequence.

concat(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources provided by a Publisher sequence as a Flowable sequence.

concat(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates elements of each ObservableSource provided via an Iterable sequence into a single sequence of elements without interleaving them.

concat(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the ObservableSource, one after the other, without interleaving them.

concat(ObservableSource>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by each of the ObservableSources emitted by the outer ObservableSource, one after the other, without interleaving them.

concat(ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by two ObservableSources, one after the other, without interleaving them.

concat(ObservableSource, ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by three ObservableSources, one after the other, without interleaving them.

concat(ObservableSource, ObservableSource, ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by four ObservableSources, one after the other, without interleaving them.

concat(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an Iterable sequence.

concat(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by an ObservableSource sequence.

concat(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence.

concat(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Single

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided by a Publisher sequence and prefetched by the specified amount.

concat(SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Flowable that emits the items emitted by two SingleSources, one after the other.

concat(SingleSource, SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Flowable that emits the items emitted by three SingleSources, one after the other.

concat(SingleSource, SingleSource, SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Flowable that emits the items emitted by four SingleSources, one after the other.

concatArray(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concatArray(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a variable number of Publisher sources.

concatArray(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenate the single values, in a non-overlapping fashion, of the MaybeSource sources in the array as a Flowable sequence.

concatArray(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates a variable number of ObservableSource sources.

concatArray(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.

concatArrayDelayError(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concatArrayDelayError(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a variable number of Publisher sources and delays errors from any of them till all terminate.

concatArrayDelayError(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a variable number of MaybeSource sources and delays errors from any of them till all terminate as a Flowable sequence.

concatArrayDelayError(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates a variable number of ObservableSource sources and delays errors from any of them till all terminate.

concatArrayDelayError(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Concatenate the single values, in a non-overlapping fashion, of the SingleSources provided in an array.

concatArrayEager(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates an array of Publishers eagerly into a single stream of values.

concatArrayEager(int, int, Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates an array of Publishers eagerly into a single stream of values.

concatArrayEager(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.

concatArrayEager(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an array of ObservableSources eagerly into a single stream of values.

concatArrayEager(int, int, ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an array of ObservableSources eagerly into a single stream of values.

concatArrayEager(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates a sequence of SingleSource eagerly into a single stream of values.

concatArrayEagerDelayError(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.

concatArrayEagerDelayError(int, int, Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates an array of Publishers eagerly into a single stream of values and delaying any errors until all sources terminate.

concatArrayEagerDelayError(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a sequence of MaybeSource eagerly into a Flowable sequence.

concatArrayEagerDelayError(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.

concatArrayEagerDelayError(int, int, ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an array of ObservableSources eagerly into a single stream of values and delaying any errors until all sources terminate.

concatArrayEagerDelayError(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates a sequence of SingleSource eagerly into a single stream of values.

concatDelayError(Iterable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concatDelayError(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concatDelayError(Publisher, int) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which completes only when all sources complete, one after another.

concatDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates the Iterable sequence of Publishers into a single sequence by subscribing to each Publisher, one after the other, one at a time and delays any errors till the all inner Publishers terminate.

concatDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.

concatDelayError(Publisher>, int, boolean) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates the Publisher sequence of Publishers into a single sequence by subscribing to each inner Publisher, one after the other, one at a time and delays any errors till the all inner and the outer Publishers terminate.

concatDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates the Iterable sequence of MaybeSources into a single sequence by subscribing to each MaybeSource, one after the other, one at a time and delays any errors till the all inner MaybeSources terminate as a Flowable sequence.

concatDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.

concatDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates the Publisher sequence of MaybeSources into a single sequence by subscribing to each inner MaybeSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.

concatDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates the Iterable sequence of ObservableSources into a single Observable sequence by subscribing to each ObservableSource, one after the other, one at a time and delays any errors till the all inner ObservableSources terminate.

concatDelayError(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates the ObservableSource sequence of ObservableSources into a single Observable sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.

concatDelayError(ObservableSource>, int, boolean) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates the ObservableSource sequence of ObservableSources into a single sequence by subscribing to each inner ObservableSource, one after the other, one at a time and delays any errors till the all inner and the outer ObservableSources terminate.

concatDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates the Iterable sequence of SingleSources into a single sequence by subscribing to each SingleSource, one after the other, one at a time and delays any errors till the all inner SingleSources terminate as a Flowable sequence.

concatDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.

concatDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates the Publisher sequence of SingleSources into a single sequence by subscribing to each inner SingleSource, one after the other, one at a time and delays any errors till the all inner and the outer Publisher terminate as a Flowable sequence.

concatEager(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a sequence of Publishers eagerly into a single stream of values.

concatEager(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a sequence of Publishers eagerly into a single stream of values and runs a limited number of inner sequences at once.

concatEager(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values.

concatEager(Publisher>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values and runs a limited number of inner sequences at once.

concatEager(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a sequence of MaybeSources eagerly into a Flowable sequence.

concatEager(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a sequence of MaybeSources eagerly into a Flowable sequence and runs a limited number of the inner sequences at once.

concatEager(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence.

concatEager(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, running at most the given number of inner MaybeSources at once.

concatEager(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates a sequence of ObservableSources eagerly into a single stream of values.

concatEager(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates a sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.

concatEager(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values.

concatEager(ObservableSource>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values and runs a limited number of inner sequences at once.

concatEager(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values.

concatEager(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values and runs a limited number of the inner sources at once.

concatEager(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values.

concatEager(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values and runs a limited number of those inner SingleSources at once.

concatEagerDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner sequences terminate.

concatEagerDelayError(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.

concatEagerDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner and the outer sequences terminate.

concatEagerDelayError(Publisher>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Concatenates a Publisher sequence of Publishers eagerly into a single stream of values, delaying errors until all the inner and outer sequences terminate and runs a limited number of inner sequences at once.

concatEagerDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate.

concatEagerDelayError(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all inner MaybeSources terminate and runs a limited number of inner MaybeSources at once.

concatEagerDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate.

concatEagerDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Concatenates a Publisher sequence of MaybeSources eagerly into a Flowable sequence, delaying errors until all the inner and the outer sequence terminate and runs a limited number of the inner MaybeSources at once.

concatEagerDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates a sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner sequences terminate.

concatEagerDelayError(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates a sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner sequences terminate and runs a limited number of inner sequences at once.

concatEagerDelayError(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.

concatEagerDelayError(ObservableSource>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Concatenates an ObservableSource sequence of ObservableSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate and runs a limited number of inner sequences at once.

concatEagerDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.

concatEagerDelayError(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates an Iterable sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner sources terminate.

concatEagerDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, delaying errors until all the inner and the outer sequence terminate.

concatEagerDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Single

Concatenates a Publisher sequence of SingleSources eagerly into a single stream of values, running at most the specified number of those inner SingleSources at once and delaying errors until all the inner and the outer sequence terminate.

concatMap(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.

concatMap(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable that emits items resulting from applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.

concatMap(Function>, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.

concatMap(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, where that function returns a MaybeSource.

concatMap(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.

concatMap(Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.

concatMap(Function>, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.

concatMap(Function>) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.

concatMap(Function>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.

concatMap(Function>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.

concatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into CompletableSources and subscribes to them one after the other completes.

concatMapCompletable(Function, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into CompletableSources and subscribes to them one after the other completes.

concatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.

concatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.

concatMapCompletable(Function, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into CompletableSources, subscribes to them one at a time in order and waits until the upstream and all CompletableSources complete.

concatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Single

Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.

concatMapCompletableDelayError(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both this Flowable and all inner CompletableSources terminate.

concatMapCompletableDelayError(Function, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.

concatMapCompletableDelayError(Function, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both this Flowable and all inner CompletableSources terminate.

concatMapCompletableDelayError(Function) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, delaying all errors till both the current Observable and all inner CompletableSources terminate.

concatMapCompletableDelayError(Function, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.

concatMapCompletableDelayError(Function, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into CompletableSources and subscribes to them one after the other terminates, optionally delaying all errors till both the current Observable and all inner CompletableSources terminate.

concatMapDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.

concatMapDelayError(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each of the items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner Publishers till all of them terminate.

concatMapDelayError(Function>, boolean, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each of the upstream items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the inner Publishers till all of them terminate.

concatMapDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.

concatMapDelayError(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.

concatMapDelayError(Function>, boolean, int, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.

concatMapDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.

concatMapDelayError(Function>, int, boolean) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and concatenates Publishers on each 'rail', optionally delaying errors and using the given prefetch amount for generating Publishers upfront.

concatMapEager(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.

concatMapEager(Function>, int, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.

concatMapEager(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

concatMapEager(Function>, int, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

concatMapEagerDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Publisher.

concatMapEagerDelayError(Function>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps a sequence of values into Publishers and concatenates these Publishers eagerly into a single Flowable sequence.

concatMapEagerDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

concatMapEagerDelayError(Function>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps a sequence of values into ObservableSources and concatenates these ObservableSources eagerly into a single Observable sequence.

concatMapIterable(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an Iterable corresponding to that item that is generated by a selector.

concatMapIterable(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that concatenate each item emitted by the current Flowable with the values in an Iterable corresponding to that item that is generated by a selector.

concatMapIterable(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that concatenate each item emitted by the current Observable with the values in an Iterable corresponding to that item that is generated by a selector.

concatMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.

concatMapMaybe(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either this Flowable or the current inner MaybeSource fail.

concatMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.

concatMapMaybe(Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into MaybeSources and subscribes to them one after the other succeeds or completes, emits their success value if available or terminates immediately if either the current Observable or the current inner MaybeSource fail.

concatMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Single

Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.

concatMapMaybeDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both this Flowable and all inner MaybeSources terminate.

concatMapMaybeDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.

concatMapMaybeDelayError(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both this Flowable and all inner MaybeSources terminate.

concatMapMaybeDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and delaying all errors till both the current Observable and all inner MaybeSources terminate.

concatMapMaybeDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.

concatMapMaybeDelayError(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into MaybeSources and subscribes to them one after the other terminates, emits their success value if available and optionally delaying all errors till both the current Observable and all inner MaybeSources terminate.

concatMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.

concatMapSingle(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either this Flowable or the current inner SingleSource fail.

concatMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.

concatMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.

concatMapSingle(Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds, emits their success values or terminates immediately if either the current Observable or the current inner SingleSource fail.

concatMapSingleDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both this Flowable and all inner SingleSources terminate.

concatMapSingleDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both this Flowable and all inner SingleSources terminate.

concatMapSingleDelayError(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both this Flowable and all inner SingleSources terminate.

concatMapSingleDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and delays all errors till both the current Observable and all inner SingleSources terminate.

concatMapSingleDelayError(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays all errors till both the current Observable and all inner SingleSources terminate.

concatMapSingleDelayError(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into SingleSources and subscribes to them one after the other succeeds or fails, emits their success values and optionally delays errors till both the current Observable and all inner SingleSources terminate.

concatMapStream(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.

concatMapStream(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.

concatMapStream(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.

concatWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Concatenates this Completable with another CompletableSource.

concatWith(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted from the current Flowable, then the next, one after the other, without interleaving them.

concatWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from this Flowable followed by the success item or error event of the other SingleSource.

concatWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from this Flowable followed by the success item or terminal events of the other MaybeSource.

concatWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items from this Flowable and when it completes normally, the other CompletableSource is subscribed to and the returned Flowable emits its terminal events.

concatWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that emits the items emitted from the current Maybe, then the other MaybeSource, one after the other, without interleaving them.

concatWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that first emits the items emitted from the current Observable, then items from the other ObservableSource without interleaving them.

concatWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable followed by the success item or error event of the other SingleSource.

concatWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable followed by the success item or terminal events of the other MaybeSource.

concatWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items from the current Observable and when it completes normally, the other CompletableSource is subscribed to and the returned Observable emits its terminal events.

concatWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Returns a Flowable that emits the item emitted by the current Single, then the item emitted by the specified SingleSource.

ConditionalSubscriber<T> - Interface in io.reactivex.rxjava3.operators

A FlowableSubscriber with an additional ConditionalSubscriber.tryOnNext(Object) method that tells the caller the specified value has been accepted or not.

connect(Consumer) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.

connect() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.

connect(Consumer) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Instructs the ConnectableObservable to begin emitting the items from its underlying Observable to its Observers.

connect() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Instructs the ConnectableObservable to begin emitting the items from its underlying Observable to its Observers.

ConnectableFlowable<T> - Class in io.reactivex.rxjava3.flowables

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) method is called.

ConnectableFlowable() - Constructor for class io.reactivex.rxjava3.flowables.ConnectableFlowable

ConnectableObservable<T> - Class in io.reactivex.rxjava3.observables

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) method is called.

ConnectableObservable() - Constructor for class io.reactivex.rxjava3.observables.ConnectableObservable

Consumer<T> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that accepts a single value.

contains(Object) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a Boolean that indicates whether the current Flowable emitted a specified item.

contains(Object) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that emits a Boolean that indicates whether the current Maybe emitted a specified item.

contains(Object) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a Boolean that indicates whether the current Observable emitted a specified item.

contains(Object) - Method in class io.reactivex.rxjava3.core.Single

Signals true if the current Single signals a success value that is Object.equals(Object) with the value provided.

contains(Object, BiPredicate) - Method in class io.reactivex.rxjava3.core.Single

Signals true if the current Single signals a success value that is equal with the value provided by calling a BiPredicate.

count() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that counts the total number of items emitted by the current Flowable and emits this count as a 64-bit Long.

count() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that counts the total number of items emitted (0 or 1) by the current Maybe and emits this count as a 64-bit Long.

count() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that counts the total number of items emitted by the current Observable and emits this count as a 64-bit Long.

create(CompletableOnSubscribe) - Static method in class io.reactivex.rxjava3.core.Completable

Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.

create(FlowableOnSubscribe, BackpressureStrategy) - Static method in class io.reactivex.rxjava3.core.Flowable

Provides an API (via a cold Flowable) that bridges the reactive world with the callback-style, generally non-backpressured world.

create(MaybeOnSubscribe) - Static method in class io.reactivex.rxjava3.core.Maybe

Provides an API (via a cold Maybe) that bridges the reactive world with the callback-style world.

create(ObservableOnSubscribe) - Static method in class io.reactivex.rxjava3.core.Observable

Provides an API (via a cold Observable) that bridges the reactive world with the callback-style world.

create(SingleOnSubscribe) - Static method in class io.reactivex.rxjava3.core.Single

Provides an API (via a cold Single) that bridges the reactive world with the callback-style world.

create() - Static method in class io.reactivex.rxjava3.observers.TestObserver

Constructs a non-forwarding TestObserver.

create(Observer) - Static method in class io.reactivex.rxjava3.observers.TestObserver

Constructs a forwarding TestObserver.

create() - Static method in class io.reactivex.rxjava3.processors.AsyncProcessor

Creates a new AsyncProcessor.

create() - Static method in class io.reactivex.rxjava3.processors.BehaviorProcessor

Creates a BehaviorProcessor without a default item.

create() - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor

Constructs a fresh instance with the default Flowable.bufferSize() prefetch amount and no refCount-behavior.

create(boolean) - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor

Constructs a fresh instance with the default Flowable.bufferSize() prefetch amount and the optional refCount-behavior.

create(int) - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor

Constructs a fresh instance with the given prefetch amount and no refCount behavior.

create(int, boolean) - Static method in class io.reactivex.rxjava3.processors.MulticastProcessor

Constructs a fresh instance with the given prefetch amount and the optional refCount-behavior.

create() - Static method in class io.reactivex.rxjava3.processors.PublishProcessor

Constructs a PublishProcessor.

create() - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor

Creates an unbounded ReplayProcessor.

create(int) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor

Creates an unbounded ReplayProcessor with the specified initial buffer capacity.

create() - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor

Creates an UnicastSubject with an internal buffer capacity hint 16.

create(int) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor

Creates an UnicastProcessor with the given internal buffer capacity hint.

create(boolean) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor

Creates an UnicastProcessor with default internal buffer capacity hint and delay error flag.

create(int, Runnable) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor

Creates an UnicastProcessor with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the processor is terminated.

create(int, Runnable, boolean) - Static method in class io.reactivex.rxjava3.processors.UnicastProcessor

Creates an UnicastProcessor with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Subscriber cancels its subscription or the processor is terminated.

create() - Static method in class io.reactivex.rxjava3.subjects.AsyncSubject

Creates a new AsyncProcessor.

create() - Static method in class io.reactivex.rxjava3.subjects.BehaviorSubject

Creates a BehaviorSubject without a default item.

create() - Static method in class io.reactivex.rxjava3.subjects.CompletableSubject

Creates a fresh CompletableSubject.

create() - Static method in class io.reactivex.rxjava3.subjects.MaybeSubject

Creates a fresh MaybeSubject.

create() - Static method in class io.reactivex.rxjava3.subjects.PublishSubject

Constructs a PublishSubject.

create() - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject

Creates an unbounded replay subject.

create(int) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject

Creates an unbounded replay subject with the specified initial buffer capacity.

create() - Static method in class io.reactivex.rxjava3.subjects.SingleSubject

Creates a fresh SingleSubject.

create() - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject

Creates an UnicastSubject with an internal buffer capacity hint 16.

create(int) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject

Creates an UnicastSubject with the given internal buffer capacity hint.

create(int, Runnable) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject

Creates an UnicastSubject with the given internal buffer capacity hint and a callback for the case when the single Subscriber cancels its subscription or the subject is terminated.

create(int, Runnable, boolean) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject

Creates an UnicastSubject with the given internal buffer capacity hint, delay error flag and a callback for the case when the single Observer disposes its Disposable or the subject is terminated.

create(boolean) - Static method in class io.reactivex.rxjava3.subjects.UnicastSubject

Creates an UnicastSubject with an internal buffer capacity hint 16 and given delay error flag.

create() - Static method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Creates a TestSubscriber with Long.MAX_VALUE initial request amount.

create(long) - Static method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Creates a TestSubscriber with the given initial request amount.

create(Subscriber) - Static method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Constructs a forwarding TestSubscriber.

createComputationScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Create an instance of the default Scheduler used for Schedulers.computation() except using threadFactory for thread creation.

createDefault() - Static method in exception io.reactivex.rxjava3.exceptions.MissingBackpressureException

Constructs a new MissingBackpressureException with the default message "Could not emit value due to lack of requests".

createDefault(T) - Static method in class io.reactivex.rxjava3.processors.BehaviorProcessor

Creates a BehaviorProcessor that emits the last item it observed and all subsequent items to each Subscriber that subscribes to it.

createDefault(T) - Static method in class io.reactivex.rxjava3.subjects.BehaviorSubject

Creates a BehaviorSubject that emits the last item it observed and all subsequent items to each Observer that subscribes to it.

createExecutorScheduler(Executor, boolean, boolean) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Create an instance of a Scheduler by wrapping an existing Executor.

createIoScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Create an instance of the default Scheduler used for Schedulers.io() except using threadFactory for thread creation.

createNewThreadScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Create an instance of the default Scheduler used for Schedulers.newThread() except using threadFactory for thread creation.

createOnComplete() - Static method in class io.reactivex.rxjava3.core.Notification

Returns the empty and stateless shared instance of a notification representing an onComplete signal.

createOnError(Throwable) - Static method in class io.reactivex.rxjava3.core.Notification

Constructs an onError notification containing the error.

createOnNext(T) - Static method in class io.reactivex.rxjava3.core.Notification

Constructs an onNext notification containing the given value.

createSingleScheduler(ThreadFactory) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Create an instance of the default Scheduler used for Schedulers.single() except using threadFactory for thread creation.

createWithSize(int) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor

Creates a size-bounded ReplayProcessor.

createWithSize(int) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject

Creates a size-bounded replay subject.

createWithTime(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor

Creates a time-bounded ReplayProcessor.

createWithTime(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject

Creates a time-bounded replay subject.

createWithTimeAndSize(long, TimeUnit, Scheduler, int) - Static method in class io.reactivex.rxjava3.processors.ReplayProcessor

Creates a time- and size-bounded ReplayProcessor.

createWithTimeAndSize(long, TimeUnit, Scheduler, int) - Static method in class io.reactivex.rxjava3.subjects.ReplaySubject

Creates a time- and size-bounded replay subject.

createWorker() - Method in class io.reactivex.rxjava3.core.Scheduler

Retrieves or creates a new Scheduler.Worker that represents sequential execution of actions.

createWorker() - Method in class io.reactivex.rxjava3.schedulers.TestScheduler

CUSTOM - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

A special value indicating the operator/class requires a scheduler to be manually specified.

D

debounce(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by another item within a computed debounce duration.

debounce(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires.

debounce(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.

debounce(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.

debounce(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by another item within a computed debounce duration denoted by an item emission or completion from a generated inner ObservableSource for that original item.

debounce(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires.

debounce(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.

debounce(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.

DEFAULT_MESSAGE - Static variable in exception io.reactivex.rxjava3.exceptions.MissingBackpressureException

The default error message.

defaultIfEmpty(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable or a specified default item if the current Flowable is empty.

defaultIfEmpty(T) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that emits the item emitted by the current Maybe or a specified default item if the current Maybe is empty.

defaultIfEmpty(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable or a specified default item if the current Observable is empty.

DefaultObserver<T> - Class in io.reactivex.rxjava3.observers

Abstract base implementation of an Observer with support for cancelling a subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart() when the subscription happens.

DefaultObserver() - Constructor for class io.reactivex.rxjava3.observers.DefaultObserver

DefaultSubscriber<T> - Class in io.reactivex.rxjava3.subscribers

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.

DefaultSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.DefaultSubscriber

defer(Supplier) - Static method in class io.reactivex.rxjava3.core.Completable

Defers the subscription to a Completable instance returned by a supplier.

defer(Supplier>) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that calls a Publisher factory to create a Publisher for each new Subscriber that subscribes.

defer(Supplier>) - Static method in class io.reactivex.rxjava3.core.Maybe

Calls a Supplier for each individual MaybeObserver to return the actual MaybeSource source to be subscribed to.

defer(Supplier>) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer that subscribes.

defer(Supplier>) - Static method in class io.reactivex.rxjava3.core.Single

Calls a Supplier for each individual SingleObserver to return the actual SingleSource to be subscribed to.

delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which delays the emission of the completion event by the given time.

delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which delays the emission of the completion event by the given time while running on the specified Scheduler.

delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified Scheduler.

delay(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that delays the emissions of the current Flowable via another Publisher on a per-item basis.

delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.

delay(Publisher, Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that delays the subscription to and emissions from the current Flowable via another Publisher on a per-item basis.

delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.

delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.

delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.

delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay running on the specified Scheduler.

delay(Publisher) - Method in class io.reactivex.rxjava3.core.Maybe

Delays the emission of this Maybe until the given Publisher signals an item or completes.

delay(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that delays the emissions of the current Observable via a per-item derived ObservableSource's item emission or termination, on a per source item basis.

delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.

delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.

delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.

delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.

delay(ObservableSource, Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that delays the subscription to and emissions from the current Observable via ObservableSources for the subscription itself and on a per-item basis.

delay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Single

Delays the emission of the success signal from the current Single by the specified amount.

delay(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Single

Delays the emission of the success or error signal from the current Single by the specified amount.

delay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Delays the emission of the success signal from the current Single by the specified amount.

delay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Single

Delays the emission of the success or error signal from the current Single by the specified amount.

delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that delays the subscription to the upstream by a given amount of time.

delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a given Scheduler.

delaySubscription(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that delays the subscription to this Publisher until the other Publisher emits an element or completes normally.

delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that delays the subscription to the current Flowable by a given amount of time.

delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that delays the subscription to the current Flowable by a given amount of time, both waiting and subscribing on a given Scheduler.

delaySubscription(Publisher) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that delays the subscription to this Maybe until the other Publisher emits an element or completes normally.

delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that delays the subscription to the current Maybe by a given amount of time.

delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that delays the subscription to the current Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.

delaySubscription(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that delays the subscription to the current Observable until the other ObservableSource emits an element or completes normally.

delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that delays the subscription to the current Observable by a given amount of time.

delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that delays the subscription to the current Observable by a given amount of time, both waiting and subscribing on a given Scheduler.

delaySubscription(CompletableSource) - Method in class io.reactivex.rxjava3.core.Single

Delays the actual subscription to the current Single until the given other CompletableSource completes.

delaySubscription(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Delays the actual subscription to the current Single until the given other SingleSource signals success.

delaySubscription(ObservableSource) - Method in class io.reactivex.rxjava3.core.Single

Delays the actual subscription to the current Single until the given other ObservableSource signals its first value or completes.

delaySubscription(Publisher) - Method in class io.reactivex.rxjava3.core.Single

Delays the actual subscription to the current Single until the given other Publisher signals its first value or completes.

delaySubscription(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Single

Delays the actual subscription to the current Single until the given time delay elapsed.

delaySubscription(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Delays the actual subscription to the current Single until the given time delay elapsed.

delete(Disposable) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

Removes (but does not dispose) the given Disposable if it is part of this container.

delete(Disposable) - Method in interface io.reactivex.rxjava3.disposables.DisposableContainer

Removes but does not dispose the given disposable if it is part of this container.

dematerialize(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Subscriber signal types.

dematerialize(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the Notification success value of the current Maybe back into normal onSuccess, onError or onComplete signals.

dematerialize(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that reverses the effect of materialize by transforming the Notification objects extracted from the source items via a selector function into their respective Observer signal types.

dematerialize(Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the Notification success value of the current Single back into normal onSuccess, onError or onComplete signals as a Maybe source.

Disposable - Interface in io.reactivex.rxjava3.disposables

Represents a disposable resource.

DisposableCompletableObserver - Class in io.reactivex.rxjava3.observers

An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable.

DisposableCompletableObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableCompletableObserver

DisposableContainer - Interface in io.reactivex.rxjava3.disposables

Common interface to add and remove disposables from a container.

DisposableMaybeObserver<T> - Class in io.reactivex.rxjava3.observers

An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.

DisposableMaybeObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableMaybeObserver

DisposableObserver<T> - Class in io.reactivex.rxjava3.observers

An abstract Observer that allows asynchronous cancellation by implementing Disposable.

DisposableObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableObserver

DisposableSingleObserver<T> - Class in io.reactivex.rxjava3.observers

An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.

DisposableSingleObserver() - Constructor for class io.reactivex.rxjava3.observers.DisposableSingleObserver

DisposableSubscriber<T> - Class in io.reactivex.rxjava3.subscribers

An abstract Subscriber that allows asynchronous, external cancellation by implementing Disposable.

DisposableSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.DisposableSubscriber

dispose() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

dispose() - Method in interface io.reactivex.rxjava3.disposables.Disposable

Dispose the resource, the operation should be idempotent.

dispose() - Method in class io.reactivex.rxjava3.disposables.SerialDisposable

dispose() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Cancel/dispose this test consumer.

dispose() - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver

dispose() - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver

dispose() - Method in class io.reactivex.rxjava3.observers.DisposableObserver

dispose() - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver

dispose() - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver

Cancels the main disposable (if any) and disposes the resources associated with this ResourceCompletableObserver (if any).

dispose() - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver

Cancels the main disposable (if any) and disposes the resources associated with this ResourceMaybeObserver (if any).

dispose() - Method in class io.reactivex.rxjava3.observers.ResourceObserver

Cancels the main disposable (if any) and disposes the resources associated with this ResourceObserver (if any).

dispose() - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver

Cancels the main disposable (if any) and disposes the resources associated with this ResourceSingleObserver (if any).

dispose() - Method in class io.reactivex.rxjava3.observers.SafeObserver

dispose() - Method in class io.reactivex.rxjava3.observers.SerializedObserver

dispose() - Method in class io.reactivex.rxjava3.observers.TestObserver

dispose() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber

dispose() - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber

Cancels the subscription (if any) and disposes the resources associated with this ResourceSubscriber (if any).

dispose() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

disposed() - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Returns a shared, disposed Disposable instance.

distinct() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits all items emitted by the current Flowable that are distinct based on Object.equals(Object) comparison.

distinct(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits all items emitted by the current Flowable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.

distinct(Function, Supplier>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits all items emitted by the current Flowable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.

distinct() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits all items emitted by the current Observable that are distinct based on Object.equals(Object) comparison.

distinct(Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.

distinct(Function, Supplier>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits all items emitted by the current Observable that are distinct according to a key selector function and based on Object.equals(Object) comparison of the objects returned by the key selector function.

distinctUntilChanged() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors based on Object.equals(Object) comparison.

distinctUntilChanged(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.

distinctUntilChanged(BiPredicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits all items emitted by the current Flowable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.

distinctUntilChanged() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors based on Object.equals(Object) comparison.

distinctUntilChanged(Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors, according to a key selector function and based on Object.equals(Object) comparison of those objects returned by the key selector function.

distinctUntilChanged(BiPredicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits all items emitted by the current Observable that are distinct from their immediate predecessors when compared with each other via the provided comparator function.

doAfterNext(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the specified consumer with the current item after this item has been emitted to the downstream.

doAfterNext(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Calls the specified Consumer with the current item after this item has been emitted to the downstream.

doAfterNext(Consumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.

doAfterSuccess(Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the specified Consumer with the success item after this item has been emitted to the downstream.

doAfterSuccess(Consumer) - Method in class io.reactivex.rxjava3.core.Single

Calls the specified consumer with the success item after this item has been emitted to the downstream.

doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that calls the given onAfterTerminate Action after this Completable completes normally or with an exception.

doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Flowable

Registers an Action to be called when this Publisher invokes either onComplete or onError.

doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Maybe

Registers an Action to be called when this Maybe invokes either onSuccess, onComplete or onError.

doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Observable

Registers an Action to be called when the current Observable invokes either onComplete or onError.

doAfterTerminate(Action) - Method in class io.reactivex.rxjava3.core.Single

Registers an Action to be called after this Single invokes either onSuccess or onError.

doAfterTerminated(Action) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Run the specified Action when a 'rail' completes or signals an error.

doFinally(Action) - Method in class io.reactivex.rxjava3.core.Completable

Calls the specified Action after this Completable signals onError or onComplete or gets disposed by the downstream.

doFinally(Action) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the specified action after this Flowable signals onError or onComplete or gets canceled by the downstream.

doFinally(Action) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the specified action after this Maybe signals onSuccess, onError or onComplete or gets disposed by the downstream.

doFinally(Action) - Method in class io.reactivex.rxjava3.core.Observable

Calls the specified action after the current Observable signals onError or onCompleted or gets disposed by the downstream.

doFinally(Action) - Method in class io.reactivex.rxjava3.core.Single

Calls the specified action after this Single signals onSuccess or onError or gets disposed by the downstream.

done - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

The latch that indicates an onError or onComplete has been called.

doOnCancel(Action) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the cancel Action if the downstream cancels the sequence.

doOnCancel(Action) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Run the specified Action when a 'rail' receives a cancellation.

doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which calls the given onComplete Action if this Completable completes.

doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Flowable

Invokes an Action just before the current Flowable calls onComplete.

doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Maybe

Invokes an Action just before the current Maybe calls onComplete.

doOnComplete(Action) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that invokes an Action when the current Observable calls onComplete.

doOnComplete(Action) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Run the specified Action when a 'rail' completes.

doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Completable

Calls the shared Action if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.

doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the shared Action if a MaybeObserver subscribed to the current Maybe disposes the common Disposable it received via onSubscribe.

doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Observable

Calls the given shared Action if the downstream disposes the sequence.

doOnDispose(Action) - Method in class io.reactivex.rxjava3.core.Single

Calls the shared Action if a SingleObserver subscribed to the current Single disposes the common Disposable it received via onSubscribe.

doOnEach(Consumer>) - Method in class io.reactivex.rxjava3.core.Flowable

Invokes a Consumer with a Notification instances matching the signals emitted by the current Flowable before they are forwarded to the downstream.

doOnEach(Subscriber) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the appropriate methods of the given Subscriber when the current Flowable signals events before forwarding it to the downstream.

doOnEach(Consumer>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that invokes a Consumer with the appropriate Notification object when the current Observable signals an item or terminates.

doOnEach(Observer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that forwards the items and terminal events of the current Observable to its Observers and to the given shared Observer instance.

doOnError(Consumer) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which calls the given onError Consumer if this Completable emits an error.

doOnError(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the given Consumer with the error Throwable if the current Flowable failed before forwarding it to the downstream.

doOnError(Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the shared Consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.

doOnError(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Calls the given Consumer with the error Throwable if the current Observable failed before forwarding it to the downstream.

doOnError(Consumer) - Method in class io.reactivex.rxjava3.core.Single

Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.

doOnError(Consumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified consumer with the exception passing through any 'rail'.

doOnEvent(Consumer) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which calls the given onEvent Consumer with the Throwable for an onError or null for an onComplete signal from this Completable before delivering the signal to the downstream.

doOnEvent(BiConsumer) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the given onEvent callback with the (success value, null) for an onSuccess, (null, throwable) for an onError or (null, null) for an onComplete signal from this Maybe before delivering said signal to the downstream.

doOnEvent(BiConsumer) - Method in class io.reactivex.rxjava3.core.Single

Calls the shared consumer with the error sent via onError or the value via onSuccess for each SingleObserver that subscribes to the current Single.

doOnLifecycle(Consumer, Action) - Method in class io.reactivex.rxjava3.core.Completable

Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of the sequence (subscription, disposal).

doOnLifecycle(Consumer, LongConsumer, Action) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).

doOnLifecycle(Consumer, Action) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of the sequence (subscription, disposal).

doOnLifecycle(Consumer, Action) - Method in class io.reactivex.rxjava3.core.Observable

Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of the sequence (subscription, disposal).

doOnLifecycle(Consumer, Action) - Method in class io.reactivex.rxjava3.core.Single

Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).

doOnNext(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the given Consumer with the value emitted by the current Flowable before forwarding it to the downstream.

doOnNext(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Calls the given Consumer with the value emitted by the current Observable before forwarding it to the downstream.

doOnNext(Consumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified consumer with the current element passing through any 'rail'.

doOnNext(Consumer, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified consumer with the current element passing through any 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.

doOnNext(Consumer, BiFunction) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.

doOnRequest(LongConsumer) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the given LongConsumer with the request amount from the downstream before forwarding it to the current Flowable.

doOnRequest(LongConsumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified consumer with the request amount if any rail receives a request.

doOnSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that calls the given onSubscribe callback with the disposable that the downstream CompletableObservers receive upon subscription.

doOnSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the given Consumer with the Subscription provided by the current Flowable upon subscription from the downstream before forwarding it to the subscriber's onSubscribe method.

doOnSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the shared Consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.

doOnSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from its Observers.

doOnSubscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Single

Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.

doOnSubscribe(Consumer) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Call the specified callback when a 'rail' receives a Subscription from its upstream.

doOnSuccess(Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the shared Consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.

doOnSuccess(Consumer) - Method in class io.reactivex.rxjava3.core.Single

Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.

doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that calls the given onTerminate Action just before this Completable completes normally or with an exception.

doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the given Action when the current Flowable completes normally or with an error before those signals are forwarded to the downstream.

doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe instance that calls the given onTerminate callback just before this Maybe completes normally or with an exception.

doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable so that it invokes an action when the current Observable calls onComplete or onError.

doOnTerminate(Action) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single instance that calls the given onTerminate callback just before this Single completes normally or with an exception.

E

elementAt(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Maybe that emits the single item at a specified index in a sequence of emissions from this Flowable or completes if this Flowable sequence has fewer elements than index.

elementAt(long, T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable, or a default item if that index is out of range.

elementAt(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Maybe that emits the single item at a specified index in a sequence of emissions from the current Observable or completes if the current Observable signals fewer elements than index.

elementAt(long, T) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable, or a default item if that index is out of range.

elementAtOrError(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits the item found at a specified index in a sequence of emissions from this Flowable or signals a NoSuchElementException if this Flowable has fewer elements than index.

elementAtOrError(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits the item found at a specified index in a sequence of emissions from the current Observable or signals a NoSuchElementException if the current Observable signals fewer elements than index.

Emitter<T> - Interface in io.reactivex.rxjava3.core

Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).

empty() - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits no items to the Subscriber and immediately invokes its onComplete method.

empty() - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a (singleton) Maybe instance that calls onComplete immediately.

empty() - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits no items to the Observer and immediately invokes its onComplete method.

empty() - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Returns a new, non-disposed Disposable instance.

equals(Object) - Method in class io.reactivex.rxjava3.core.Notification

equals(Object) - Method in class io.reactivex.rxjava3.schedulers.Timed

error(Supplier) - Static method in class io.reactivex.rxjava3.core.Completable

Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.

error(Throwable) - Static method in class io.reactivex.rxjava3.core.Completable

Creates a Completable instance that emits the given Throwable exception to subscribers.

error(Supplier) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.

error(Throwable) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that invokes a Subscriber's onError method when the Subscriber subscribes to it.

error(Throwable) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that invokes a subscriber's onError method when the subscriber subscribes to it.

error(Supplier) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that invokes a MaybeObserver's onError method when the MaybeObserver subscribes to it.

error(Supplier) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.

error(Throwable) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that invokes an Observer's onError method when the Observer subscribes to it.

error(Supplier) - Static method in class io.reactivex.rxjava3.core.Single

Signals a Throwable returned by the callback function for each individual SingleObserver.

error(Throwable) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that invokes a subscriber's onError method when the subscriber subscribes to it.

errors - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

The list of errors received.

Exceptions - Class in io.reactivex.rxjava3.exceptions

Utility class to help propagate checked exceptions and rethrow exceptions designated as fatal.

Experimental - Annotation Type in io.reactivex.rxjava3.annotations

Indicates the feature is in experimental state: its existence, signature or behavior might change without warning from one release to the next.

F

fail(String) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Fail with the given message and add the sequence of errors as suppressed ones.

filter(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Filters items emitted by the current Flowable by only emitting those that satisfy a specified predicate.

filter(Predicate) - Method in class io.reactivex.rxjava3.core.Maybe

Filters the success item of the Maybe via a predicate function and emitting it if the predicate returns true, completing otherwise.

filter(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Filters items emitted by the current Observable by only emitting those that satisfy a specified Predicate.

filter(Predicate) - Method in class io.reactivex.rxjava3.core.Single

Filters the success item of the Single via a predicate function and emitting it if the predicate returns true, completing otherwise.

filter(Predicate) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Filters the source values on each 'rail'.

filter(Predicate, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Filters the source values on each 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.

filter(Predicate, BiFunction) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.

first(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits only the very first item emitted by this Flowable, or a default item if this Flowable completes without emitting anything.

first(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits only the very first item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.

firstElement() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Maybe that emits only the very first item emitted by this Flowable or completes if this Flowable is empty.

firstElement() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Maybe that emits only the very first item emitted by the current Observable, or completes if the current Observable is empty.

firstOrError() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits only the very first item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.

firstOrError() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits only the very first item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.

firstOrErrorStage() - Method in class io.reactivex.rxjava3.core.Flowable

Signals the first upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.

firstOrErrorStage() - Method in class io.reactivex.rxjava3.core.Observable

Signals the first upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.

firstStage(T) - Method in class io.reactivex.rxjava3.core.Flowable

Signals the first upstream item (or the default item if the upstream is empty) via a CompletionStage.

firstStage(T) - Method in class io.reactivex.rxjava3.core.Observable

Signals the first upstream item (or the default item if the upstream is empty) via a CompletionStage.

flatMap(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.

flatMap(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger.

flatMap(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items based on applying a function that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then merging those resulting Publishers and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>, Function>, Supplier>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that applies a function to each item emitted or notification raised by the current Flowable and then flattens the Publishers returned from these functions and emits the resulting items.

flatMap(Function>, Function>, Supplier>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that applies a function to each item emitted or notification raised by the current Flowable and then flattens the Publishers returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher.

flatMap(Function>, BiFunction, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified inner Publisher.

flatMap(Function>, BiFunction, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>, BiFunction, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>, BiFunction, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified function to the pair of values emitted by the current Flowable and a specified collection Publisher, while limiting the maximum number of concurrent subscriptions to these Publishers.

flatMap(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that is based on applying a specified function to the item emitted by the current Maybe, where that function returns a MaybeSource.

flatMap(Function>, Function>, Supplier>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the onSuccess, onError or onComplete signals of the current Maybe into a MaybeSource and emits that MaybeSource's signals.

flatMap(Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified function to the pair of values emitted by the current Maybe and a specified mapped MaybeSource.

flatMap(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.

flatMap(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger.

flatMap(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>, Function>, Supplier>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items.

flatMap(Function>, Function>, Supplier>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that applies a function to each item emitted or notification raised by the current Observable and then flattens the ObservableSources returned from these functions and emits the resulting items, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then merging those returned ObservableSources and emitting the results of this merger, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.

flatMap(Function>, BiFunction, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource.

flatMap(Function>, BiFunction, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>, BiFunction, boolean, int, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>, BiFunction, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified function to the pair of values emitted by the current Observable and the mapped inner ObservableSource, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

flatMap(Function>) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that is based on applying a specified function to the item emitted by the current Single, where that function returns a SingleSource.

flatMap(Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified function to the pair of values emitted by the current Single and a specified mapped SingleSource.

flatMap(Function>, Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the onSuccess or onError signals of the current Single into a SingleSource and emits that SingleSource's signals.

flatMap(Function>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and flattens Publishers on each 'rail'.

flatMap(Function>, boolean) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and flattens Publishers on each 'rail', optionally delaying errors.

flatMap(Function>, boolean, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.

flatMap(Function>, boolean, int, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.

flatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.

flatMapCompletable(Function, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each element of the upstream Flowable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.

flatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Completable that completes based on applying a specified function to the item emitted by the current Maybe, where that function returns a Completable.

flatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete.

flatMapCompletable(Function, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into CompletableSources, subscribes to them and waits until the upstream and all CompletableSources complete, optionally delaying all errors.

flatMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Single

Returns a Completable that completes based on applying a specified function to the item emitted by the current Single, where that function returns a CompletableSource.

flatMapIterable(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence.

flatMapIterable(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence.

flatMapIterable(Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.

flatMapIterable(Function>, BiFunction, int) - Method in class io.reactivex.rxjava3.core.Flowable

Merges Iterables generated by a mapper Function for each individual item emitted by the current Flowable into a single Flowable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.

flatMapIterable(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable sequence.

flatMapIterable(Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Merges Iterables generated by a mapper Function for each individual item emitted by the current Observable into a single Observable sequence where the resulting items will be the combination of the original item and each inner item of the respective Iterable as returned by the resultSelector BiFunction.

flatMapIterable(Function>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Returns a ParallelFlowable that merges each item emitted by the source on each rail with the values in an Iterable corresponding to that item that is generated by a selector.

flatMapIterable(Function>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Returns a ParallelFlowable that merges each item emitted by the source ParallelFlowable with the values in an Iterable corresponding to that item that is generated by a selector.

flatMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each element of the upstream Flowable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.

flatMapMaybe(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each element of the upstream Flowable into MaybeSources, subscribes to at most maxConcurrency MaybeSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.

flatMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into MaybeSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.

flatMapMaybe(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into MaybeSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.

flatMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Single

Returns a Maybe that is based on applying a specified function to the item emitted by the current Single, where that function returns a MaybeSource.

flatMapObservable(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns an Observable that is based on applying a specified function to the item emitted by the current Maybe, where that function returns an ObservableSource.

flatMapObservable(Function>) - Method in class io.reactivex.rxjava3.core.Single

Returns an Observable that is based on applying a specified function to the item emitted by the current Single, where that function returns an ObservableSource.

flatMapPublisher(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Maybe, where that function returns a Publisher.

flatMapPublisher(Function>) - Method in class io.reactivex.rxjava3.core.Single

Returns a Flowable that emits items based on applying a specified function to the item emitted by the current Single, where that function returns a Publisher.

flatMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each element of the upstream Flowable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Flowable sequence.

flatMapSingle(Function>, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each element of the upstream Flowable into SingleSources, subscribes to at most maxConcurrency SingleSources at a time and merges their onSuccess values, in no particular order, into a single Flowable sequence, optionally delaying all errors.

flatMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe based on applying a specified function to the item emitted by the current Maybe, where that function returns a Single.

flatMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into SingleSources, subscribes to all of them and merges their onSuccess values, in no particular order, into a single Observable sequence.

flatMapSingle(Function>, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Maps each element of the current Observable into SingleSources, subscribes to them and merges their onSuccess values, in no particular order, into a single Observable sequence, optionally delaying all errors.

flatMapStream(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.

flatMapStream(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.

flatMapStream(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps each upstream item into a Stream and emits the Stream's items to the downstream in a sequential fashion.

flatMapStream(Function>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.

flatMapStream(Function>, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.

flattenAsFlowable(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the success value of the current Maybe into an Iterable and emits its items as a Flowable sequence.

flattenAsFlowable(Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the success value of the current Single into an Iterable and emits its items as a Flowable sequence.

flattenAsObservable(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the success value of the current Maybe into an Iterable and emits its items as an Observable sequence.

flattenAsObservable(Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the success value of the current Single into an Iterable and emits its items as an Observable sequence.

flattenStreamAsFlowable(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.

flattenStreamAsFlowable(Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as a Flowable.

flattenStreamAsObservable(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.

flattenStreamAsObservable(Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the upstream succecss value into a Java Stream and emits its items to the downstream consumer as an Observable.

Flowable<T> - Class in io.reactivex.rxjava3.core

The Flowable class that implements the Reactive Streams Publisher Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.

Flowable() - Constructor for class io.reactivex.rxjava3.core.Flowable

FlowableConverter<T,R> - Interface in io.reactivex.rxjava3.core

Convenience interface and callback used by the Flowable.to(io.reactivex.rxjava3.core.FlowableConverter) operator to turn a Flowable into another value fluently.

FlowableEmitter<T> - Interface in io.reactivex.rxjava3.core

Abstraction over a Reactive Streams Subscriber that allows associating a resource with it and exposes the current number of downstream requested amount.

FlowableOnSubscribe<T> - Interface in io.reactivex.rxjava3.core

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 in io.reactivex.rxjava3.core

Interface to map/wrap a downstream Subscriber to an upstream Subscriber.

FlowableProcessor<T> - Class in io.reactivex.rxjava3.processors

Represents a Subscriber and a Flowable (Publisher) at the same time, allowing multicasting events from a single source to multiple child Subscribers.

FlowableProcessor() - Constructor for class io.reactivex.rxjava3.processors.FlowableProcessor

FlowableSubscriber<T> - Interface in io.reactivex.rxjava3.core

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 in io.reactivex.rxjava3.core

Interface to compose Flowables.

forEach(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and receives notifications for each element.

forEach(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the ObservableSource and calls a Consumer for each item of the current Observable on its emission thread.

forEachWhile(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and receives notifications for each element until the onNext Predicate returns false.

forEachWhile(Predicate, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and receives notifications for each element and error events until the onNext Predicate returns false.

forEachWhile(Predicate, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and receives notifications for each element and the terminal events until the onNext Predicate returns false.

forEachWhile(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the ObservableSource and calls a Predicate for each item of the current Observable, on its emission thread, until the predicate returns false.

forEachWhile(Predicate, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the ObservableSource and calls a Predicate for each item or a Consumer with the error of the current Observable, on their original emission threads, until the predicate returns false.

forEachWhile(Predicate, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the ObservableSource and calls a Predicate for each item, a Consumer with the error or an Action upon completion of the current Observable, on their original emission threads, until the predicate returns false.

from(Publisher) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.

from(Publisher, int) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.

from(Publisher, int, int) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Take a Publisher and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.

from(Executor) - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Wraps an Executor into a new Scheduler instance and delegates schedule() calls to it.

from(Executor, boolean) - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Wraps an Executor into a new Scheduler instance and delegates schedule() calls to it.

from(Executor, boolean, boolean) - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Wraps an Executor into a new Scheduler instance and delegates schedule() calls to it.

fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that runs the given Action for each CompletableObserver and emits either an exception or simply completes.

fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable instance that runs the given Action for each Subscriber and emits either its exception or simply completes.

fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe instance that runs the given Action for each MaybeObserver and emits either its exception or simply completes.

fromAction(Action) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable instance that runs the given Action for each Observer and emits either its exception or simply completes.

fromAction(Action) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct a Disposable by wrapping a Action that is executed exactly once when the Disposable is disposed.

fromArray(T...) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts an array into a Publisher that emits the items in the array.

fromArray(T...) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an array into an ObservableSource that emits the items in the array.

fromArray(Publisher...) - Static method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Wraps multiple Publishers into a ParallelFlowable which runs them in parallel and unordered.

fromAutoCloseable(AutoCloseable) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct a Disposable by wrapping an AutoCloseable that is closed exactly once when the Disposable is disposed.

fromCallable(Callable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which when subscribed, executes the Callable function, ignores its normal result and emits onError or onComplete only.

fromCallable(Callable) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that, when a Subscriber subscribes to it, invokes a function you specify and then emits the value returned from that function.

fromCallable(Callable) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that invokes the given Callable for each individual MaybeObserver that subscribes and emits the resulting non-null item via onSuccess while considering a null result from the Callable as indication for valueless completion via onComplete.

fromCallable(Callable) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that, when an observer subscribes to it, invokes a function you specify and then emits the value returned from that function.

fromCallable(Callable) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that invokes the given Callable for each incoming SingleObserver and emits its value or exception to them.

fromCompletable(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Flowable

Wraps a CompletableSource into a Flowable.

fromCompletable(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Wraps a CompletableSource into a Maybe.

fromCompletable(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Wraps a CompletableSource into an Observable.

fromCompletionStage(CompletionStage) - Static method in class io.reactivex.rxjava3.core.Completable

Signals completion (or error) when the CompletionStage terminates.

fromCompletionStage(CompletionStage) - Static method in class io.reactivex.rxjava3.core.Flowable

Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.

fromCompletionStage(CompletionStage) - Static method in class io.reactivex.rxjava3.core.Maybe

Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.

fromCompletionStage(CompletionStage) - Static method in class io.reactivex.rxjava3.core.Observable

Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.

fromCompletionStage(CompletionStage) - Static method in class io.reactivex.rxjava3.core.Single

Signals the completion value or error of the given (hot) CompletionStage-based asynchronous calculation.

fromFuture(Future) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.

fromFuture(Future) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Future into a Publisher.

fromFuture(Future, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Future into a Publisher, with a timeout on the Future.

fromFuture(Future) - Static method in class io.reactivex.rxjava3.core.Maybe

Converts a Future into a Maybe, treating a null result as an indication of emptiness.

fromFuture(Future, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Maybe

Converts a Future into a Maybe, with a timeout on the Future.

fromFuture(Future) - Static method in class io.reactivex.rxjava3.core.Observable

Converts a Future into an Observable.

fromFuture(Future, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable

Converts a Future into an Observable, with a timeout on the Future.

fromFuture(Future) - Static method in class io.reactivex.rxjava3.core.Single

Converts a Future into a Single and awaits its outcome in a blocking fashion.

fromFuture(Future, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Single

Converts a Future into a Single and awaits its outcome, or timeout, in a blocking fashion.

fromFuture(Future) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct a Disposable by wrapping a Future that is cancelled exactly once when the Disposable is disposed.

fromFuture(Future, boolean) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct a Disposable by wrapping a Future that is cancelled exactly once when the Disposable is disposed.

fromIterable(Iterable) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts an Iterable sequence into a Publisher that emits the items in the sequence.

fromIterable(Iterable) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an Iterable sequence into an Observable that emits the items in the sequence.

fromMaybe(MaybeSource) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that when subscribed to, subscribes to the MaybeSource instance and emits an onComplete event if the maybe emits onSuccess/onComplete or forwards any onError events.

fromMaybe(MaybeSource) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.

fromMaybe(MaybeSource) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item or forwards any onComplete or onError signal.

fromMaybe(MaybeSource) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, turns an onComplete into NoSuchElementException error signal or forwards the onError signal.

fromMaybe(MaybeSource, T) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single instance that when subscribed to, subscribes to the MaybeSource instance and emits onSuccess as a single item, emits the defaultItem for an onComplete signal or forwards the onError signal.

fromObservable(ObservableSource) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that subscribes to the given ObservableSource, ignores all values and emits only the terminal event.

fromObservable(ObservableSource, BackpressureStrategy) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts the given ObservableSource into a Flowable by applying the specified backpressure strategy.

fromObservable(ObservableSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Wraps an ObservableSource into a Maybe and emits the very first item or completes if the source is empty.

fromObservable(ObservableSource) - Static method in class io.reactivex.rxjava3.core.Single

Wraps a specific ObservableSource into a Single and signals its single element or error.

fromOptional(Optional) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts the existing value of the provided optional into a Flowable.just(Object) or an empty optional into an Flowable.empty() Flowable instance.

fromOptional(Optional) - Static method in class io.reactivex.rxjava3.core.Maybe

Converts the existing value of the provided optional into a Maybe.just(Object) or an empty optional into an Maybe.empty() Maybe instance.

fromOptional(Optional) - Static method in class io.reactivex.rxjava3.core.Observable

Converts the existing value of the provided optional into a Observable.just(Object) or an empty optional into an Observable.empty() Observable instance.

fromPublisher(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that subscribes to the given Publisher, ignores all values and emits only the terminal event.

fromPublisher(Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts an arbitrary Reactive Streams Publisher into a Flowable if not already a Flowable.

fromPublisher(Publisher) - Static method in class io.reactivex.rxjava3.core.Maybe

Wraps a Publisher into a Maybe and emits the very first item or completes if the source is empty.

fromPublisher(Publisher) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an arbitrary Reactive Streams Publisher into an Observable.

fromPublisher(Publisher) - Static method in class io.reactivex.rxjava3.core.Single

Wraps a specific Publisher into a Single and signals its single element or error.

fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that runs the given Runnable for each CompletableObserver and emits either its unchecked exception or simply completes.

fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable instance that runs the given Runnable for each Subscriber and emits either its unchecked exception or simply completes.

fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe instance that runs the given Runnable for each MaybeObserver and emits either its unchecked exception or simply completes.

fromRunnable(Runnable) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable instance that runs the given Runnable for each Observer and emits either its unchecked exception or simply completes.

fromRunnable(Runnable) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct a Disposable by wrapping a Runnable that is executed exactly once when the Disposable is disposed.

fromSingle(SingleSource) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that when subscribed to, subscribes to the SingleSource instance and emits a completion event if the single emits onSuccess or forwards any onError events.

fromSingle(SingleSource) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.

fromSingle(SingleSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Wraps a SingleSource into a Maybe.

fromSingle(SingleSource) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable instance that when subscribed to, subscribes to the SingleSource instance and emits onSuccess as a single item or forwards the onError signal.

fromStream(Stream) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Stream into a finite Flowable and emits its items in the sequence.

fromStream(Stream) - Static method in class io.reactivex.rxjava3.core.Observable

Converts a Stream into a finite Observable and emits its items in the sequence.

fromSubscription(Subscription) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct a Disposable by wrapping a Subscription that is cancelled exactly once when the Disposable is disposed.

fromSupplier(Supplier) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which when subscribed, executes the Supplier function, ignores its normal result and emits onError or onComplete only.

fromSupplier(Supplier) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that, when a Subscriber subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.

fromSupplier(Supplier) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that invokes the given Supplier for each individual MaybeObserver that subscribes and emits the resulting non-null item via onSuccess while considering a null result from the Supplier as indication for valueless completion via onComplete.

fromSupplier(Supplier) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that, when an observer subscribes to it, invokes a supplier function you specify and then emits the value returned from that function.

fromSupplier(Supplier) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that invokes passed supplier and emits its result for each individual SingleObserver that subscribes.

Function<T,R> - Interface in io.reactivex.rxjava3.functions

A functional interface that takes a value and returns another value, possibly with a different type and allows throwing a checked exception.

Function3<T1,T2,T3,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

Function4<T1,T2,T3,T4,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

Function5<T1,T2,T3,T4,T5,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

Function6<T1,T2,T3,T4,T5,T6,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

Function7<T1,T2,T3,T4,T5,T6,T7,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that computes a value based on multiple input values.

G

generate(Consumer>) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a cold, synchronous, stateless and backpressure-aware generator of values.

generate(Supplier, BiConsumer>) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

generate(Supplier, BiConsumer>, Consumer) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

generate(Supplier, BiFunction, S>) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

generate(Supplier, BiFunction, S>, Consumer) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

generate(Consumer>) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a cold, synchronous and stateless generator of values.

generate(Supplier, BiConsumer>) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a cold, synchronous and stateful generator of values.

generate(Supplier, BiConsumer>, Consumer) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a cold, synchronous and stateful generator of values.

generate(Supplier, BiFunction, S>) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a cold, synchronous and stateful generator of values.

generate(Supplier, BiFunction, S>, Consumer) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a cold, synchronous and stateful generator of values.

get() - Method in class io.reactivex.rxjava3.disposables.SerialDisposable

Returns the currently contained Disposable or null if this container is empty.

get() - Method in interface io.reactivex.rxjava3.functions.Supplier

Produces a value or throws an exception.

get() - Method in interface io.reactivex.rxjava3.operators.ScalarSupplier

getAsBoolean() - Method in interface io.reactivex.rxjava3.functions.BooleanSupplier

Returns a boolean value.

getCause() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

getComputationSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getError() - Method in class io.reactivex.rxjava3.core.Notification

Returns the container Throwable error if this notification is an onError signal, null otherwise.

getErrorHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the a hook consumer.

getExceptions() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

Retrieves the list of exceptions that make up the CompositeException.

getInitComputationSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getInitIoSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getInitNewThreadSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getInitSingleSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getIoSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getKey() - Method in class io.reactivex.rxjava3.flowables.GroupedFlowable

Returns the key that identifies the group of items emitted by this GroupedFlowable.

getKey() - Method in class io.reactivex.rxjava3.observables.GroupedObservable

Returns the key that identifies the group of items emitted by this GroupedObservable.

getMessage() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

getNewThreadSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnBeforeBlocking() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current blocking handler or null if no custom handler is set.

getOnCompletableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnCompletableSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnConnectableFlowableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnConnectableObservableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnFlowableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnFlowableSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnMaybeAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnMaybeSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnObservableAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnObservableSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnParallelAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnParallelSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnSingleAssembly() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getOnSingleSubscribe() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getScheduleHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getSingleSchedulerHandler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns the current hook function.

getThrowable() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

getThrowable() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

getThrowable() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor

Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor hasn't terminated yet.

getThrowable() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

getThrowable() - Method in class io.reactivex.rxjava3.processors.PublishProcessor

getThrowable() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

getThrowable() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

getThrowable() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

getThrowable() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

getThrowable() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

Returns the terminal error if this CompletableSubject has been terminated with an error, null otherwise.

getThrowable() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

Returns the terminal error if this MaybeSubject has been terminated with an error, null otherwise.

getThrowable() - Method in class io.reactivex.rxjava3.subjects.PublishSubject

getThrowable() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

getThrowable() - Method in class io.reactivex.rxjava3.subjects.SingleSubject

Returns the terminal error if this SingleSubject has been terminated with an error, null otherwise.

getThrowable() - Method in class io.reactivex.rxjava3.subjects.Subject

Returns the error that caused the Subject to terminate or null if the Subject hasn't terminated yet.

getThrowable() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

getValue() - Method in class io.reactivex.rxjava3.core.Notification

Returns the contained value if this notification is an onNext signal, null otherwise.

getValue() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

Returns a single value this processor currently has or null if no such value exists.

getValue() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

Returns a single value the BehaviorProcessor currently has or null if no such value exists.

getValue() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

Returns the latest value this processor has or null if no such value exists.

getValue() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

Returns a single value the Subject currently has or null if no such value exists.

getValue() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

Returns a single value the Subject currently has or null if no such value exists.

getValue() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

Returns the success value if this MaybeSubject was terminated with a success value.

getValue() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

Returns a single value the Subject currently has or null if no such value exists.

getValue() - Method in class io.reactivex.rxjava3.subjects.SingleSubject

Returns the success value if this SingleSubject was terminated with a success value.

getValues() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

Returns an Object array containing snapshot all values of this processor.

getValues(T[]) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

Returns a typed array containing a snapshot of all values of this processor.

getValues() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

Returns an Object array containing snapshot all values of the Subject.

getValues(T[]) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

Returns a typed array containing a snapshot of all values of the Subject.

getWrappedRunnable() - Method in interface io.reactivex.rxjava3.schedulers.SchedulerRunnableIntrospection

Returns the wrapped action.

groupBy(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.

groupBy(Function, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.

groupBy(Function, Function) - Method in class io.reactivex.rxjava3.core.Flowable

Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.

groupBy(Function, Function, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.

groupBy(Function, Function, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.

groupBy(Function, Function, boolean, int, Function, ? extends Map>) - Method in class io.reactivex.rxjava3.core.Flowable

Groups the items emitted by the current Flowable according to a specified criterion, and emits these grouped items as GroupedFlowables.

groupBy(Function) - Method in class io.reactivex.rxjava3.core.Observable

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

groupBy(Function, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

groupBy(Function, Function) - Method in class io.reactivex.rxjava3.core.Observable

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

groupBy(Function, Function, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

groupBy(Function, Function, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Groups the items emitted by the current Observable according to a specified criterion, and emits these grouped items as GroupedObservables.

GroupedFlowable<K,T> - Class in io.reactivex.rxjava3.flowables

A Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().

GroupedFlowable(K) - Constructor for class io.reactivex.rxjava3.flowables.GroupedFlowable

Constructs a GroupedFlowable with the given key.

GroupedObservable<K,T> - Class in io.reactivex.rxjava3.observables

An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().

GroupedObservable(K) - Constructor for class io.reactivex.rxjava3.observables.GroupedObservable

Constructs a GroupedObservable with the given key.

groupJoin(Publisher, Function>, Function>, BiFunction, ? extends R>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that correlates two Publishers when they overlap in time and groups the results.

groupJoin(ObservableSource, Function>, Function>, BiFunction, ? extends R>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that correlates two ObservableSources when they overlap in time and groups the results.

H

hasComplete() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

hasComplete() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

hasComplete() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor

Returns true if the FlowableProcessor has reached a terminal state through a complete event.

hasComplete() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

hasComplete() - Method in class io.reactivex.rxjava3.processors.PublishProcessor

hasComplete() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

hasComplete() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

hasComplete() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

hasComplete() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

hasComplete() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

Returns true if this CompletableSubject has been completed.

hasComplete() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

Returns true if this MaybeSubject has been completed.

hasComplete() - Method in class io.reactivex.rxjava3.subjects.PublishSubject

hasComplete() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

hasComplete() - Method in class io.reactivex.rxjava3.subjects.Subject

Returns true if the subject has reached a terminal state through a complete event.

hasComplete() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

hasCustomOnError() - Method in interface io.reactivex.rxjava3.observers.LambdaConsumerIntrospection

Returns true or false if a custom onError consumer has been provided.

hashCode() - Method in class io.reactivex.rxjava3.core.Notification

hashCode() - Method in class io.reactivex.rxjava3.schedulers.Timed

hasObservers() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

hasObservers() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

hasObservers() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

Returns true if this CompletableSubject has observers.

hasObservers() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

Returns true if this MaybeSubject has observers.

hasObservers() - Method in class io.reactivex.rxjava3.subjects.PublishSubject

hasObservers() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

hasObservers() - Method in class io.reactivex.rxjava3.subjects.SingleSubject

Returns true if this SingleSubject has observers.

hasObservers() - Method in class io.reactivex.rxjava3.subjects.Subject

Returns true if the subject has any Observers.

hasObservers() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor

Returns true if the FlowableProcessor has subscribers.

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.PublishProcessor

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

hasSubscribers() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

hasSubscription() - Method in class io.reactivex.rxjava3.observers.TestObserver

Returns true if this TestObserver received a subscription.

hasSubscription() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Returns true if this TestSubscriber received a Subscription via TestSubscriber.onSubscribe(Subscription).

hasThrowable() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

hasThrowable() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

hasThrowable() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor

Returns true if the FlowableProcessor has reached a terminal state through an error event.

hasThrowable() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

hasThrowable() - Method in class io.reactivex.rxjava3.processors.PublishProcessor

hasThrowable() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

hasThrowable() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

Returns true if this CompletableSubject has been terminated with an error.

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

Returns true if this MaybeSubject has been terminated with an error.

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.PublishSubject

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.SingleSubject

Returns true if this SingleSubject has been terminated with an error.

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.Subject

Returns true if the subject has reached a terminal state through an error event.

hasThrowable() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

hasValue() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

Returns true if this processor has any value.

hasValue() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

Returns true if the BehaviorProcessor has any value.

hasValue() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

Returns true if this processor has any value.

hasValue() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

Returns true if the subject has any value.

hasValue() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

Returns true if the subject has any value.

hasValue() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

Returns true if this MaybeSubject was terminated with a success value.

hasValue() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

Returns true if the subject has any value.

hasValue() - Method in class io.reactivex.rxjava3.subjects.SingleSubject

Returns true if this SingleSubject was terminated with a success value.

hide() - Method in class io.reactivex.rxjava3.core.Completable

Hides the identity of this Completable and its Disposable.

hide() - Method in class io.reactivex.rxjava3.core.Flowable

Hides the identity of this Flowable and its Subscription.

hide() - Method in class io.reactivex.rxjava3.core.Maybe

Hides the identity of this Maybe and its Disposable.

hide() - Method in class io.reactivex.rxjava3.core.Observable

Hides the identity of the current Observable and its Disposable.

hide() - Method in class io.reactivex.rxjava3.core.Single

Hides the identity of the current Single, including the Disposable that is sent to the downstream via onSubscribe().

I

ignoreElement() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Completable that ignores the item emitted by the current Maybe and only calls onComplete or onError.

ignoreElement() - Method in class io.reactivex.rxjava3.core.Single

Returns a Completable that ignores the success value of this Single and signals onComplete instead.

ignoreElements() - Method in class io.reactivex.rxjava3.core.Flowable

Ignores all items emitted by the current Flowable and only calls onComplete or onError.

ignoreElements() - Method in class io.reactivex.rxjava3.core.Observable

Ignores all items emitted by the current Observable and only calls onComplete or onError.

initComputationScheduler(Supplier) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

initIoScheduler(Supplier) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

initNewThreadScheduler(Supplier) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

initSingleScheduler(Supplier) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

interval(long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter.

interval(long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, on a specified Scheduler.

interval(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a sequential number every specified interval of time.

interval(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.

interval(long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter.

interval(long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, on a specified Scheduler.

interval(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a sequential number every specified interval of time.

interval(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.

intervalRange(long, long, long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable

Signals a range of long values, the first after some initial delay and the rest periodically after.

intervalRange(long, long, long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable

Signals a range of long values, the first after some initial delay and the rest periodically after.

intervalRange(long, long, long, long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable

Signals a range of long values, the first after some initial delay and the rest periodically after.

intervalRange(long, long, long, long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable

Signals a range of long values, the first after some initial delay and the rest periodically after.

IntFunction<T> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that takes a primitive value and return value of type T.

IO - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

The operator/class runs on RxJava's I/O scheduler or takes timing information from it.

io() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Returns a default, shared Scheduler instance intended for IO-bound work.

io.reactivex.rxjava3.annotations - package io.reactivex.rxjava3.annotations

Annotations for indicating operator behavior, API stability (@Experimental and @Beta) and nullability indicators (Nullable and NonNull).

io.reactivex.rxjava3.core - package io.reactivex.rxjava3.core

Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.

io.reactivex.rxjava3.disposables - package io.reactivex.rxjava3.disposables

Default implementations for Disposable-based resource management (Disposable container types) and utility classes to construct Disposables from callbacks and other types.

io.reactivex.rxjava3.exceptions - package io.reactivex.rxjava3.exceptions

Exception handling utilities (Exceptions), composite exception container (CompositeException) and various lifecycle-related (UndeliverableException) and behavior-violation exception types (OnErrorNotImplementedException, MissingBackpressureException).

io.reactivex.rxjava3.flowables - package io.reactivex.rxjava3.flowables

Classes supporting the Flowable base reactive class: ConnectableFlowable and GroupedFlowable.

io.reactivex.rxjava3.functions - package io.reactivex.rxjava3.functions

Functional interfaces of functions and actions of arity 0 to 9 and related utility classes.

io.reactivex.rxjava3.observables - package io.reactivex.rxjava3.observables

Classes supporting the Observable base reactive class: ConnectableObservable and GroupedObservable.

io.reactivex.rxjava3.observers - package io.reactivex.rxjava3.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.rxjava3.operators - package io.reactivex.rxjava3.operators

Classes and interfaces for writing advanced operators within and outside RxJava.

io.reactivex.rxjava3.parallel - package io.reactivex.rxjava3.parallel

Contains the base type ParallelFlowable, a sub-DSL for working with Flowable sequences in parallel.

io.reactivex.rxjava3.plugins - package io.reactivex.rxjava3.plugins

Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.

io.reactivex.rxjava3.processors - package io.reactivex.rxjava3.processors

Classes representing so-called hot backpressure-aware sources, aka processors, that implement the FlowableProcessor class, the Reactive Streams Processor interface to allow forms of multicasting events to one or more subscribers as well as consuming another Reactive Streams Publisher.

io.reactivex.rxjava3.schedulers - package io.reactivex.rxjava3.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.rxjava3.subjects - package io.reactivex.rxjava3.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.rxjava3.subscribers - package io.reactivex.rxjava3.subscribers

Default wrappers and implementations for Subscriber-based consumer classes and interfaces, including disposable (DisposableSubscriber) and resource-tracking (ResourceSubscriber) variants and the TestSubscriber that allows unit testing Flowable-based flows.

isCancelled() - Method in interface io.reactivex.rxjava3.core.FlowableEmitter

Returns true if the downstream cancelled the sequence or the emitter was terminated via Emitter.onError(Throwable), Emitter.onComplete() or a successful FlowableEmitter.tryOnError(Throwable).

isCancelled() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Returns true if this TestSubscriber has been cancelled.

isDisposed() - Method in interface io.reactivex.rxjava3.core.CompletableEmitter

Returns true if the downstream disposed the sequence or the emitter was terminated via CompletableEmitter.onError(Throwable), CompletableEmitter.onComplete() or a successful CompletableEmitter.tryOnError(Throwable).

isDisposed() - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Returns true if the downstream disposed the sequence or the emitter was terminated via MaybeEmitter.onSuccess(Object), MaybeEmitter.onError(Throwable), MaybeEmitter.onComplete() or a successful MaybeEmitter.tryOnError(Throwable).

isDisposed() - Method in interface io.reactivex.rxjava3.core.ObservableEmitter

Returns true if the downstream disposed the sequence or the emitter was terminated via Emitter.onError(Throwable), Emitter.onComplete() or a successful ObservableEmitter.tryOnError(Throwable).

isDisposed() - Method in interface io.reactivex.rxjava3.core.SingleEmitter

Returns true if the downstream disposed the sequence or the emitter was terminated via SingleEmitter.onSuccess(Object), SingleEmitter.onError(Throwable), or a successful SingleEmitter.tryOnError(Throwable).

isDisposed() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

isDisposed() - Method in interface io.reactivex.rxjava3.disposables.Disposable

Returns true if this resource has been disposed.

isDisposed() - Method in class io.reactivex.rxjava3.disposables.SerialDisposable

isDisposed() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Returns true if this test consumer was cancelled/disposed.

isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver

isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver

isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableObserver

isDisposed() - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver

isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver

Returns true if this ResourceCompletableObserver has been disposed/cancelled.

isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver

Returns true if this ResourceMaybeObserver has been disposed/cancelled.

isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceObserver

Returns true if this ResourceObserver has been disposed/cancelled.

isDisposed() - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver

Returns true if this ResourceSingleObserver has been disposed/cancelled.

isDisposed() - Method in class io.reactivex.rxjava3.observers.SafeObserver

isDisposed() - Method in class io.reactivex.rxjava3.observers.SerializedObserver

isDisposed() - Method in class io.reactivex.rxjava3.observers.TestObserver

isDisposed() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber

isDisposed() - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber

Returns true if this ResourceSubscriber has been disposed/cancelled.

isDisposed() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

isEmpty() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits true if the current Flowable is empty, otherwise false.

isEmpty() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that emits true if the current Maybe is empty, otherwise false.

isEmpty() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits true if the current Observable is empty, otherwise false.

isEmpty() - Method in interface io.reactivex.rxjava3.operators.SimpleQueue

Returns true if the queue is empty.

isEmpty() - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue

isEmpty() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

isFailOnNonBlockingScheduler() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns true if the blockingX operators fail with an IllegalStateException on a non-blocking scheduler such as computation or single.

isLockdown() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Returns true if the plugins were locked down.

isOnComplete() - Method in class io.reactivex.rxjava3.core.Notification

Returns true if this notification is an onComplete signal.

isOnError() - Method in class io.reactivex.rxjava3.core.Notification

Returns true if this notification is an onError signal and Notification.getError() returns the contained Throwable.

isOnNext() - Method in class io.reactivex.rxjava3.core.Notification

Returns true if this notification is an onNext signal and Notification.getValue() returns the contained value.

J

join(Publisher, Function>, Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Correlates the items emitted by two Publishers based on overlapping durations.

join(ObservableSource, Function>, Function>, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Correlates the items emitted by two ObservableSources based on overlapping durations.

just(T) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that signals the given (constant reference) item and then completes.

just(T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts two items into a Publisher that emits those items.

just(T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts three items into a Publisher that emits those items.

just(T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts four items into a Publisher that emits those items.

just(T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts five items into a Publisher that emits those items.

just(T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts six items into a Publisher that emits those items.

just(T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts seven items into a Publisher that emits those items.

just(T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts eight items into a Publisher that emits those items.

just(T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts nine items into a Publisher that emits those items.

just(T, T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts ten items into a Publisher that emits those items.

just(T) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits a specified item.

just(T) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that signals the given (constant reference) item and then completes.

just(T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts two items into an Observable that emits those items.

just(T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts three items into an Observable that emits those items.

just(T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts four items into an Observable that emits those items.

just(T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts five items into an Observable that emits those items.

just(T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts six items into an Observable that emits those items.

just(T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts seven items into an Observable that emits those items.

just(T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts eight items into an Observable that emits those items.

just(T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts nine items into an Observable that emits those items.

just(T, T, T, T, T, T, T, T, T, T) - Static method in class io.reactivex.rxjava3.core.Observable

Converts ten items into an Observable that emits those items.

just(T) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits a specified item.

L

LambdaConsumerIntrospection - Interface in io.reactivex.rxjava3.observers

An interface that indicates that the implementing type is composed of individual components and exposes information about their behavior.

last(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits only the last item emitted by this Flowable, or a default item if this Flowable completes without emitting any items.

last(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits only the last item emitted by the current Observable, or a default item if the current Observable completes without emitting any items.

lastElement() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Maybe that emits the last item emitted by this Flowable or completes if this Flowable is empty.

lastElement() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Maybe that emits the last item emitted by the current Observable or completes if the current Observable is empty.

lastOrError() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits only the last item emitted by this Flowable or signals a NoSuchElementException if this Flowable is empty.

lastOrError() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits only the last item emitted by the current Observable or signals a NoSuchElementException if the current Observable is empty.

lastOrErrorStage() - Method in class io.reactivex.rxjava3.core.Flowable

Signals the last upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.

lastOrErrorStage() - Method in class io.reactivex.rxjava3.core.Observable

Signals the last upstream item or a NoSuchElementException if the upstream is empty via a CompletionStage.

lastStage(T) - Method in class io.reactivex.rxjava3.core.Flowable

Signals the last upstream item (or the default item if the upstream is empty) via a CompletionStage.

lastStage(T) - Method in class io.reactivex.rxjava3.core.Observable

Signals the last upstream item (or the default item if the upstream is empty) via a CompletionStage.

lastThread - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

The last thread seen by the observer.

lift(CompletableOperator) - Method in class io.reactivex.rxjava3.core.Completable

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Completable which, when subscribed to, invokes the apply(CompletableObserver) method of the provided CompletableOperator for each individual downstream Completable and allows the insertion of a custom operator by accessing the downstream's CompletableObserver during this subscription phase and providing a new CompletableObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

lift(FlowableOperator) - Method in class io.reactivex.rxjava3.core.Flowable

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Flowable which, when subscribed to, invokes the apply(Subscriber) method of the provided FlowableOperator for each individual downstream Subscriber and allows the insertion of a custom operator by accessing the downstream's Subscriber during this subscription phase and providing a new Subscriber, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

lift(MaybeOperator) - Method in class io.reactivex.rxjava3.core.Maybe

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Maybe which, when subscribed to, invokes the apply(MaybeObserver) method of the provided MaybeOperator for each individual downstream Maybe and allows the insertion of a custom operator by accessing the downstream's MaybeObserver during this subscription phase and providing a new MaybeObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

lift(ObservableOperator) - Method in class io.reactivex.rxjava3.core.Observable

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns an Observable which, when subscribed to, invokes the apply(Observer) method of the provided ObservableOperator for each individual downstream Observer and allows the insertion of a custom operator by accessing the downstream's Observer during this subscription phase and providing a new Observer, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

lift(SingleOperator) - Method in class io.reactivex.rxjava3.core.Single

This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a Single which, when subscribed to, invokes the apply(SingleObserver) method of the provided SingleOperator for each individual downstream Single and allows the insertion of a custom operator by accessing the downstream's SingleObserver during this subscription phase and providing a new SingleObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.

lockdown() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Prevents changing the plugins from then on.

LongConsumer - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that consumes a primitive long value.

M

map(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that applies a specified function to each item emitted by the current Flowable and emits the results of these function applications.

map(Function) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that applies a specified function to the item emitted by the current Maybe and emits the result of this function application.

map(Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that applies a specified function to each item emitted by the current Observable and emits the results of these function applications.

map(Function) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that applies a specified function to the item emitted by the current Single and emits the result of this function application.

map(Function) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps the source values on each 'rail' to another value.

map(Function, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps the source values on each 'rail' to another value and handles errors based on the given ParallelFailureHandling enumeration value.

map(Function, BiFunction) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.

mapOptional(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps each upstream value into an Optional and emits the contained item if not empty.

mapOptional(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Maps the upstream success value into an Optional and emits the contained item if not empty.

mapOptional(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps each upstream value into an Optional and emits the contained item if not empty.

mapOptional(Function>) - Method in class io.reactivex.rxjava3.core.Single

Maps the upstream success value into an Optional and emits the contained item if not empty as a Maybe.

mapOptional(Function>) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps the source values on each 'rail' to an optional and emits its value if any.

mapOptional(Function>, ParallelFailureHandling) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the given ParallelFailureHandling enumeration value.

mapOptional(Function>, BiFunction) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.

materialize() - Method in class io.reactivex.rxjava3.core.Completable

Maps the signal types of this Completable into a Notification of the same kind and emits it as a single success value to downstream.

materialize() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that represents all of the emissions and notifications from the current Flowable into emissions marked with their original types within Notification objects.

materialize() - Method in class io.reactivex.rxjava3.core.Maybe

Maps the signal types of this Maybe into a Notification of the same kind and emits it as a Single's onSuccess value to downstream.

materialize() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that represents all of the emissions and notifications from the current Observable into emissions marked with their original types within Notification objects.

materialize() - Method in class io.reactivex.rxjava3.core.Single

Maps the signal types of this Single into a Notification of the same kind and emits it as a single success value to downstream.

Maybe<T> - Class in io.reactivex.rxjava3.core

The Maybe class represents a deferred computation and emission of a single value, no value at all or an exception.

Maybe() - Constructor for class io.reactivex.rxjava3.core.Maybe

MaybeConverter<T,R> - Interface in io.reactivex.rxjava3.core

Convenience interface and callback used by the Maybe.to(io.reactivex.rxjava3.core.MaybeConverter) operator to turn a Maybe into another value fluently.

MaybeEmitter<T> - Interface in io.reactivex.rxjava3.core

Abstraction over an RxJava MaybeObserver that allows associating a resource with it.

MaybeObserver<T> - Interface in io.reactivex.rxjava3.core

Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.

MaybeOnSubscribe<T> - Interface in io.reactivex.rxjava3.core

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 in io.reactivex.rxjava3.core

Interface to map/wrap a downstream MaybeObserver to an upstream MaybeObserver.

MaybeSource<T> - Interface in io.reactivex.rxjava3.core

Represents a basic Maybe source base interface, consumable via an MaybeObserver.

MaybeSubject<T> - Class in io.reactivex.rxjava3.subjects

Represents a hot Maybe-like source and consumer of events similar to Subjects.

MaybeTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core

Interface to compose Maybes.

merge(Iterable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.

merge(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.

merge(Publisher, int) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source CompletableSources complete or one of them emits an error.

merge(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.

merge(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an Iterable of Publishers into one Publisher, without any transformation.

merge(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an Iterable of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.

merge(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by thos Publishers , without any transformation.

merge(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens a Publisher that emits Publishers into a single Publisher that emits the items emitted by those Publishers, without any transformation, while limiting the maximum number of concurrent subscriptions to these Publishers.

merge(Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens two Publishers into a single Publisher, without any transformation.

merge(Publisher, Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens three Publishers into a single Publisher, without any transformation.

merge(Publisher, Publisher, Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens four Publishers into a single Publisher, without any transformation.

merge(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Merges an Iterable sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.

merge(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.

merge(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Merges a Publisher sequence of MaybeSource instances into a single Flowable sequence, running at most maxConcurrency MaybeSources at once.

merge(MaybeSource>) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens a MaybeSource that emits a MaybeSource into a single MaybeSource that emits the item emitted by the nested MaybeSource, without any transformation.

merge(MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens two MaybeSources into a single Flowable, without any transformation.

merge(MaybeSource, MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens three MaybeSources into a single Flowable, without any transformation.

merge(MaybeSource, MaybeSource, MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens four MaybeSources into a single Flowable, without any transformation.

merge(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.

merge(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an Iterable of ObservableSources into one Observable, without any transformation.

merge(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an Iterable of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.

merge(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation.

merge(ObservableSource>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an ObservableSource that emits ObservableSources into a single Observable that emits the items emitted by those ObservableSources, without any transformation, while limiting the maximum number of concurrent subscriptions to these ObservableSources.

merge(ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens two ObservableSources into a single Observable, without any transformation.

merge(ObservableSource, ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens three ObservableSources into a single Observable, without any transformation.

merge(ObservableSource, ObservableSource, ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens four ObservableSources into a single Observable, without any transformation.

merge(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Merges an Iterable sequence of SingleSource instances into a single Flowable sequence, running all SingleSources at once.

merge(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Merges a sequence of SingleSource instances emitted by a Publisher into a single Flowable sequence, running all SingleSources at once.

merge(SingleSource>) - Static method in class io.reactivex.rxjava3.core.Single

Flattens a SingleSource that emits a SingleSingle into a single Single that emits the item emitted by the nested SingleSource, without any transformation.

merge(SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Flattens two SingleSources into one Flowable sequence, without any transformation.

merge(SingleSource, SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Flattens three SingleSources into one Flowable sequence, without any transformation.

merge(SingleSource, SingleSource, SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Flattens four SingleSources into one Flowable sequence, without any transformation.

mergeArray(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that subscribes to all sources at once and completes only when all source CompletableSources complete or one of them emits an error.

mergeArray(int, int, Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an array of Publishers into one Publisher, without any transformation, while limiting the number of concurrent subscriptions to these Publishers.

mergeArray(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an array of Publishers into one Publisher, without any transformation.

mergeArray(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Merges an array of MaybeSource instances into a single Flowable sequence, running all MaybeSources at once.

mergeArray(int, int, ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an array of ObservableSources into one Observable, without any transformation, while limiting the number of concurrent subscriptions to these ObservableSources.

mergeArray(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an array of ObservableSources into one Observable, without any transformation.

mergeArray(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Merges an array of SingleSource instances into a single Flowable sequence, running all SingleSources at once.

mergeArrayDelayError(CompletableSource...) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that subscribes to all CompletableSources in the source array and delays any error emitted by any of the inner CompletableSources until all of them terminate in a way or another.

mergeArrayDelayError(int, int, Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an array of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

mergeArrayDelayError(Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an array of Publishers into one Flowable, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.

mergeArrayDelayError(MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens an array of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.

mergeArrayDelayError(int, int, ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

mergeArrayDelayError(ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an array of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.

mergeArrayDelayError(SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Flattens an array of SingleSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source SingleSources without being interrupted by an error notification from one of them.

mergeDelayError(Iterable) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that subscribes to all CompletableSources in the source sequence and delays any error emitted by any of the inner CompletableSources until all of them terminate in a way or another.

mergeDelayError(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that subscribes to all CompletableSources in the source sequence and delays any error emitted by either the sources Publisher or any of the inner CompletableSources until all of them terminate in a way or another.

mergeDelayError(Publisher, int) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that subscribes to a limited number of inner CompletableSources at once in the source sequence and delays any error emitted by either the sources Publisher or any of the inner CompletableSources until all of them terminate in a way or another.

mergeDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.

mergeDelayError(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

mergeDelayError(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens an Iterable of Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

mergeDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

mergeDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens a Publisher that emits Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these Publishers.

mergeDelayError(Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens two Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from each of the source Publishers without being interrupted by an error notification from one of them.

mergeDelayError(Publisher, Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens three Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

mergeDelayError(Publisher, Publisher, Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Flattens four Publishers into one Publisher, in a way that allows a Subscriber to receive all successfully emitted items from all of the source Publishers without being interrupted by an error notification from one of them.

mergeDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens an Iterable sequence of MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.

mergeDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher.

mergeDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens a Publisher that emits MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them or even the main Publisher as well as limiting the total number of active MaybeSources.

mergeDelayError(MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens two MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from each of the source MaybeSources without being interrupted by an error notification from one of them.

mergeDelayError(MaybeSource, MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens three MaybeSource into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.

mergeDelayError(MaybeSource, MaybeSource, MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Flattens four MaybeSources into one Flowable, in a way that allows a subscriber to receive all successfully emitted items from all of the source MaybeSources without being interrupted by an error notification from one of them.

mergeDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them.

mergeDelayError(Iterable>, int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

mergeDelayError(Iterable>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an Iterable of ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the returned ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

mergeDelayError(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them.

mergeDelayError(ObservableSource>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens an ObservableSource that emits ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the emitted ObservableSources without being interrupted by an error notification from one of them, while limiting the number of concurrent subscriptions to these ObservableSources.

mergeDelayError(ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens two ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from each of the ObservableSources without being interrupted by an error notification from one of them.

mergeDelayError(ObservableSource, ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens three ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.

mergeDelayError(ObservableSource, ObservableSource, ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Flattens four ObservableSources into one Observable, in a way that allows an Observer to receive all successfully emitted items from all of the ObservableSources without being interrupted by an error notification from one of them.

mergeDelayError(Iterable>) - Static method in class io.reactivex.rxjava3.core.Single

Merges an Iterable sequence of SingleSource instances into one Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.

mergeDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Merges a sequence of SingleSource instances emitted by a Publisher into a Flowable sequence, running all SingleSources at once and delaying any error(s) until all sources succeed or fail.

mergeDelayError(SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.

mergeDelayError(SingleSource, SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.

mergeDelayError(SingleSource, SingleSource, SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Flattens two SingleSources into one Flowable, without any transformation, delaying any error(s) until all sources succeed or fail.

mergeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which subscribes to this and the other CompletableSource and completes when both of them complete or one emits an error.

mergeWith(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Flattens this and another Publisher into a single Publisher, without any transformation.

mergeWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Flowable

Merges the sequence of items of this Flowable with the success value of the other SingleSource.

mergeWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Flowable

Merges the sequence of items of this Flowable with the success value of the other MaybeSource or waits for both to complete normally if the MaybeSource is empty.

mergeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Flowable

Relays the items of this Flowable and completes only when the other CompletableSource completes as well.

mergeWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Flattens this Maybe and another MaybeSource into a single Flowable, without any transformation.

mergeWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Flattens the current Observable and another ObservableSource into a single Observable sequence, without any transformation.

mergeWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Observable

Merges the sequence of items of the current Observable with the success value of the other SingleSource.

mergeWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Observable

Merges the sequence of items of the current Observable with the success value of the other MaybeSource or waits both to complete normally if the MaybeSource is empty.

mergeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Observable

Relays the items of the current Observable and completes only when the other CompletableSource completes as well.

mergeWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Flattens this Single and another SingleSource into one Flowable, without any transformation.

MissingBackpressureException - Exception in io.reactivex.rxjava3.exceptions

Indicates that an operator attempted to emit a value but the downstream wasn't ready for it.

MissingBackpressureException() - Constructor for exception io.reactivex.rxjava3.exceptions.MissingBackpressureException

Constructs a MissingBackpressureException without message or cause.

MissingBackpressureException(String) - Constructor for exception io.reactivex.rxjava3.exceptions.MissingBackpressureException

Constructs a MissingBackpressureException with the given message but no cause.

MulticastProcessor<T> - Class in io.reactivex.rxjava3.processors

A FlowableProcessor implementation that coordinates downstream requests through a front-buffer and stable-prefetching, optionally canceling the upstream if all subscribers have cancelled.

N

never() - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that never calls onError or onComplete.

never() - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that never sends any items or notifications to a Subscriber.

never() - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that never sends any items or notifications to a MaybeObserver.

never() - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that never sends any items or notifications to an Observer.

never() - Static method in class io.reactivex.rxjava3.core.Single

Returns a singleton instance of a never-signaling Single (only calls onSubscribe).

NEW_THREAD - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

The operator/class runs on RxJava's new thread scheduler or takes timing information from it.

newThread() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Returns a default, shared Scheduler instance that creates a new Thread for each unit of work.

NONE - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

A special value indicating the operator/class doesn't use schedulers.

NONE - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable

Returned by the QueueFuseable.requestFusion(int) if the upstream doesn't support the requested mode.

NonNull - Annotation Type in io.reactivex.rxjava3.annotations

Indicates that a field/parameter/variable/type parameter/return type is never null.

Notification<T> - Class in io.reactivex.rxjava3.core

Represents the reactive signal types: onNext, onError and onComplete and holds their parameter values (a value, a Throwable, nothing).

now(TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler

Returns the 'current time' of the Scheduler in the specified time unit.

now(TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker

Returns the 'current time' of the Worker in the specified time unit.

now(TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.TestScheduler

Nullable - Annotation Type in io.reactivex.rxjava3.annotations

Indicates that a field/parameter/variable/type parameter/return type may be null.

O

Observable<T> - Class in io.reactivex.rxjava3.core

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.

Observable() - Constructor for class io.reactivex.rxjava3.core.Observable

ObservableConverter<T,R> - Interface in io.reactivex.rxjava3.core

Convenience interface and callback used by the Observable.to(io.reactivex.rxjava3.core.ObservableConverter) operator to turn an Observable into another value fluently.

ObservableEmitter<T> - Interface in io.reactivex.rxjava3.core

Abstraction over an RxJava Observer that allows associating a resource with it.

ObservableOnSubscribe<T> - Interface in io.reactivex.rxjava3.core

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 in io.reactivex.rxjava3.core

Interface to map/wrap a downstream Observer to an upstream Observer.

ObservableSource<T> - Interface in io.reactivex.rxjava3.core

Represents a basic, non-backpressured Observable source base interface, consumable via an Observer.

ObservableTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core

Interface to compose Observables.

observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which emits the terminal events from the thread of the specified Scheduler.

observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer of Flowable.bufferSize() slots.

observeOn(Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer and optionally delays onError notifications.

observeOn(Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.

observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.

observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".

observeOn(Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.

observeOn(Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.

observeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Signals the success item or the terminal signals of the current Single on the specified Scheduler, asynchronously.

Observer<T> - Interface in io.reactivex.rxjava3.core

Provides a mechanism for receiving push-based notifications.

offer(T) - Method in interface io.reactivex.rxjava3.operators.SimpleQueue

Atomically enqueue a single value.

offer(T, T) - Method in interface io.reactivex.rxjava3.operators.SimpleQueue

Atomically enqueue two values.

offer(E) - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue

offer(E, E) - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue

offer(T) - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

Atomically enqueue a single value.

offer(T, T) - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

Offer two elements at the same time.

offer(T) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

Tries to emit the item to all currently subscribed Subscribers if all of them has requested some value, returns false otherwise.

offer(T) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

Tries to offer an item into the internal queue and returns false if the queue is full.

offer(T) - Method in class io.reactivex.rxjava3.processors.PublishProcessor

Tries to emit the item to all currently subscribed Subscribers if all of them has requested some value, returns false otherwise.

ofType(Class) - Method in class io.reactivex.rxjava3.core.Flowable

Filters the items emitted by the current Flowable, only emitting those of the specified type.

ofType(Class) - Method in class io.reactivex.rxjava3.core.Maybe

Filters the items emitted by the current Maybe, only emitting its success value if that is an instance of the supplied Class.

ofType(Class) - Method in class io.reactivex.rxjava3.core.Observable

Filters the items emitted by the current Observable, only emitting those of the specified type.

ofType(Class) - Method in class io.reactivex.rxjava3.core.Single

Filters the items emitted by the current Single, only emitting its success value if that is an instance of the supplied Class.

onAssembly(Maybe) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(Flowable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(ConnectableFlowable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(Observable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(ConnectableObservable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(Single) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(Completable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onAssembly(ParallelFlowable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onBackpressureBuffer() - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

onBackpressureBuffer(boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, optionally delaying an error until all buffered items have been consumed.

onBackpressureBuffer(int) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.

onBackpressureBuffer(int, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, and canceling the flow.

onBackpressureBuffer(int, boolean, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

onBackpressureBuffer(int, boolean, boolean, Action) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

onBackpressureBuffer(int, boolean, boolean, Action, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

onBackpressureBuffer(int, Action) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an limited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place, however, the resulting Flowable will signal a MissingBackpressureException via onError as soon as the buffer's capacity is exceeded, dropping all undelivered items, canceling the flow and calling the onOverflow action.

onBackpressureBuffer(long, Action, BackpressureOverflowStrategy) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

onBackpressureBuffer(long, Action, BackpressureOverflowStrategy, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Buffers an optionally unlimited number of items from the current Flowable and allows it to emit as fast it can while allowing the downstream to consume the items at its own place.

onBackpressureDrop() - Method in class io.reactivex.rxjava3.core.Flowable

Drops items from the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it).

onBackpressureDrop(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Drops items from the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and calls the given Consumer with such dropped items.

onBackpressureLatest() - Method in class io.reactivex.rxjava3.core.Flowable

Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest item when the downstream becomes ready.

onBackpressureLatest(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Drops all but the latest item emitted by the current Flowable if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest item when the downstream becomes ready.

onBackpressureReduce(BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Reduces a sequence of two not emitted values via a function into a single value if the downstream is not ready to receive new items (indicated by a lack of Subscription.request(long) calls from it) and emits this latest item when the downstream becomes ready.

onBackpressureReduce(Supplier, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Reduces upstream values into an aggregate value, provided by a supplier and combined via a reducer function, while the downstream is not ready to receive items, then emits this aggregate value when the downstream becomes ready.

onBeforeBlocking() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Called before an operator attempts a blocking operation such as awaiting a condition or signal and should return true to indicate the operator should not block but throw an IllegalArgumentException.

onComplete() - Method in interface io.reactivex.rxjava3.core.CompletableEmitter

Signal the completion.

onComplete() - Method in interface io.reactivex.rxjava3.core.CompletableObserver

Called once the deferred computation completes normally.

onComplete() - Method in interface io.reactivex.rxjava3.core.Emitter

Signal a completion.

onComplete() - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Signal the completion.

onComplete() - Method in interface io.reactivex.rxjava3.core.MaybeObserver

Called once the deferred computation completes normally.

onComplete() - Method in interface io.reactivex.rxjava3.core.Observer

Notifies the Observer that the Observable has finished sending push-based notifications.

onComplete() - Method in class io.reactivex.rxjava3.observers.SafeObserver

onComplete() - Method in class io.reactivex.rxjava3.observers.SerializedObserver

onComplete() - Method in class io.reactivex.rxjava3.observers.TestObserver

onComplete() - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

onComplete() - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

onComplete() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

onComplete() - Method in class io.reactivex.rxjava3.processors.PublishProcessor

onComplete() - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

onComplete() - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

onComplete() - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

onComplete() - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

onComplete() - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

onComplete() - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

onComplete() - Method in class io.reactivex.rxjava3.subjects.PublishSubject

onComplete() - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

onComplete() - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

onComplete() - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber

onComplete() - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber

onComplete() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

onComputationScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter

Signal an exception.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.CompletableObserver

Called once if the deferred computation 'throws' an exception.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.Emitter

Signal a Throwable exception.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Signal an exception.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.MaybeObserver

Notifies the MaybeObserver that the Maybe has experienced an error condition.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.Observer

Notifies the Observer that the Observable has experienced an error condition.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter

Signal an exception.

onError(Throwable) - Method in interface io.reactivex.rxjava3.core.SingleObserver

Notifies the SingleObserver that the Single has experienced an error condition.

onError(Throwable) - Method in class io.reactivex.rxjava3.observers.SafeObserver

onError(Throwable) - Method in class io.reactivex.rxjava3.observers.SerializedObserver

onError(Throwable) - Method in class io.reactivex.rxjava3.observers.TestObserver

onError(Throwable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Called when an undeliverable error occurs.

onError(Throwable) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

onError(Throwable) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

onError(Throwable) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

onError(Throwable) - Method in class io.reactivex.rxjava3.processors.PublishProcessor

onError(Throwable) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

onError(Throwable) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.PublishSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.SingleSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

onError(Throwable) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber

onError(Throwable) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber

onError(Throwable) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

onErrorComplete() - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the upstream Throwable.

onErrorComplete(Predicate) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that if this Completable emits an error and the Predicate returns true, it will emit an onComplete and swallow the Throwable.

onErrorComplete() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable instance that if the current Flowable emits an error, it will emit an onComplete and swallow the throwable.

onErrorComplete(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable instance that if the current Flowable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

onErrorComplete() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe instance that if this Maybe emits an error, it will emit an onComplete and swallow the throwable.

onErrorComplete(Predicate) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe instance that if this Maybe emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

onErrorComplete() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable instance that if the current Observable emits an error, it will emit an onComplete and swallow the throwable.

onErrorComplete(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable instance that if the current Observable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

onErrorComplete() - Method in class io.reactivex.rxjava3.core.Single

Returns a Maybe instance that if the current Single emits an error, it will emit an onComplete and swallow the throwable.

onErrorComplete(Predicate) - Method in class io.reactivex.rxjava3.core.Single

Returns a Maybe instance that if this Single emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.

OnErrorNotImplementedException - Exception in io.reactivex.rxjava3.exceptions

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.

OnErrorNotImplementedException(String, Throwable) - Constructor for exception io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException

Customizes the Throwable with a custom message and wraps it before it is signalled to the RxJavaPlugins.onError() handler as OnErrorNotImplementedException.

OnErrorNotImplementedException(Throwable) - Constructor for exception io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException

Wraps the Throwable before it is signalled to the RxJavaPlugins.onError() handler as OnErrorNotImplementedException.

onErrorResumeNext(Function) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper Function that returns a CompletableSource instance for it and resumes the execution with it.

onErrorResumeNext(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Resumes the flow with a Publisher returned for the failure Throwable of the current Flowable by a function instead of signaling the error via onError.

onErrorResumeNext(Function>) - Method in class io.reactivex.rxjava3.core.Maybe

Resumes the flow with a MaybeSource returned for the failure Throwable of the current Maybe by a function instead of signaling the error via onError.

onErrorResumeNext(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Resumes the flow with an ObservableSource returned for the failure Throwable of the current Observable by a function instead of signaling the error via onError.

onErrorResumeNext(Function>) - Method in class io.reactivex.rxjava3.core.Single

Resumes the flow with a SingleSource returned for the failure Throwable of the current Single by a function instead of signaling the error via onError.

onErrorResumeWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Resumes the flow with the given CompletableSource when the current Completable fails instead of signaling the error via onError.

onErrorResumeWith(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Resumes the flow with the given Publisher when the current Flowable fails instead of signaling the error via onError.

onErrorResumeWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Resumes the flow with the given MaybeSource when the current Maybe fails instead of signaling the error via onError.

onErrorResumeWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Resumes the flow with the given ObservableSource when the current Observable fails instead of signaling the error via onError.

onErrorResumeWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Resumes the flow with the given SingleSource when the current Single fails instead of signaling the error via onError.

onErrorReturn(Function) - Method in class io.reactivex.rxjava3.core.Completable

Ends the flow with a success item returned by a function for the Throwable error signaled by the current Completable instead of signaling the error via onError.

onErrorReturn(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Ends the flow with a last item returned by a function for the Throwable error signaled by the current Flowable instead of signaling the error via onError.

onErrorReturn(Function) - Method in class io.reactivex.rxjava3.core.Maybe

Ends the flow with a success item returned by a function for the Throwable error signaled by the current Maybe instead of signaling the error via onError.

onErrorReturn(Function) - Method in class io.reactivex.rxjava3.core.Observable

Ends the flow with a last item returned by a function for the Throwable error signaled by the current Observable instead of signaling the error via onError.

onErrorReturn(Function) - Method in class io.reactivex.rxjava3.core.Single

Ends the flow with a success item returned by a function for the Throwable error signaled by the current Single instead of signaling the error via onError.

onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Completable

Ends the flow with the given success item when the current Completable fails instead of signaling the error via onError.

onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Flowable

Ends the flow with the given last item when the current Flowable fails instead of signaling the error via onError.

onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Maybe

Ends the flow with the given success item when the current Maybe fails instead of signaling the error via onError.

onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Observable

Ends the flow with the given last item when the current Observable fails instead of signaling the error via onError.

onErrorReturnItem(T) - Method in class io.reactivex.rxjava3.core.Single

Signals the specified value as success in case the current Single signals an error.

onIoScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onNewThreadScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onNext(T) - Method in interface io.reactivex.rxjava3.core.Emitter

Signal a normal value.

onNext(T) - Method in interface io.reactivex.rxjava3.core.Observer

Provides the Observer with a new item to observe.

onNext(T) - Method in class io.reactivex.rxjava3.observers.SafeObserver

onNext(T) - Method in class io.reactivex.rxjava3.observers.SerializedObserver

onNext(T) - Method in class io.reactivex.rxjava3.observers.TestObserver

onNext(T) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

onNext(T) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

onNext(T) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

onNext(T) - Method in class io.reactivex.rxjava3.processors.PublishProcessor

onNext(T) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

onNext(T) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

onNext(T) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

onNext(T) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

onNext(T) - Method in class io.reactivex.rxjava3.subjects.PublishSubject

onNext(T) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

onNext(T) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

onNext(T) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber

onNext(T) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber

onNext(T) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

onSchedule(Runnable) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Called when a task is scheduled.

onSingleScheduler(Scheduler) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onStart() - Method in class io.reactivex.rxjava3.observers.DefaultObserver

Called once the subscription has been set on this observer; override this to perform initialization.

onStart() - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver

Called once the single upstream Disposable is set via DisposableCompletableObserver.onSubscribe(Disposable).

onStart() - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver

Called once the single upstream Disposable is set via DisposableMaybeObserver.onSubscribe(Disposable).

onStart() - Method in class io.reactivex.rxjava3.observers.DisposableObserver

Called once the single upstream Disposable is set via onSubscribe.

onStart() - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver

Called once the single upstream Disposable is set via DisposableSingleObserver.onSubscribe(Disposable).

onStart() - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver

Called once the upstream sets a Disposable on this ResourceCompletableObserver.

onStart() - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver

Called once the upstream sets a Disposable on this ResourceMaybeObserver.

onStart() - Method in class io.reactivex.rxjava3.observers.ResourceObserver

Called once the upstream sets a Disposable on this ResourceObserver.

onStart() - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver

Called once the upstream sets a Disposable on this ResourceSingleObserver.

onStart() - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber

Called once the subscription has been set on this observer; override this to perform initialization or issue an initial request.

onStart() - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber

Called once the single upstream Subscription is set via DisposableSubscriber.onSubscribe(Subscription).

onStart() - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber

Called once the upstream sets a Subscription on this ResourceSubscriber.

onStart() - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Called after the onSubscribe is called and handled.

onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.CompletableObserver

Called once by the Completable to set a Disposable on this instance which then can be used to cancel the subscription at any time.

onSubscribe(Subscription) - Method in interface io.reactivex.rxjava3.core.FlowableSubscriber

Implementors of this method should make sure everything that needs to be visible in Subscriber.onNext(Object) is established before calling Subscription.request(long).

onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.MaybeObserver

Provides the MaybeObserver with the means of cancelling (disposing) the connection (channel) with the Maybe in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.

onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.Observer

Provides the Observer with the means of cancelling (disposing) the connection (channel) with the Observable in both synchronous (from within Observer.onNext(Object)) and asynchronous manner.

onSubscribe(Disposable) - Method in interface io.reactivex.rxjava3.core.SingleObserver

Provides the SingleObserver with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DefaultObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableCompletableObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableMaybeObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.DisposableSingleObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceCompletableObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceMaybeObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.ResourceSingleObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.SafeObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.SerializedObserver

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.observers.TestObserver

onSubscribe(Flowable, Subscriber) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onSubscribe(Observable, Observer) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onSubscribe(Single, SingleObserver) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onSubscribe(Completable, CompletableObserver) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onSubscribe(Maybe, MaybeObserver) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onSubscribe(ParallelFlowable, Subscriber[]) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Calls the associated hook function.

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.PublishProcessor

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.PublishSubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.SingleSubject

onSubscribe(Disposable) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber

onSubscribe(Subscription) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

onSuccess(T) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Signal a success value.

onSuccess(T) - Method in interface io.reactivex.rxjava3.core.MaybeObserver

Notifies the MaybeObserver with one item and that the Maybe has finished sending push-based notifications.

onSuccess(T) - Method in interface io.reactivex.rxjava3.core.SingleEmitter

Signal a success value.

onSuccess(T) - Method in interface io.reactivex.rxjava3.core.SingleObserver

Notifies the SingleObserver with a single item and that the Single has finished sending push-based notifications.

onSuccess(T) - Method in class io.reactivex.rxjava3.observers.TestObserver

onSuccess(T) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

onSuccess(T) - Method in class io.reactivex.rxjava3.subjects.SingleSubject

onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Completable

Nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose().

onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Flowable

Nulls out references to the upstream producer and downstream Subscriber if the sequence is terminated or downstream cancels.

onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Maybe

Nulls out references to the upstream producer and downstream MaybeObserver if the sequence is terminated or downstream calls dispose().

onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Observable

Nulls out references to the upstream producer and downstream Observer if the sequence is terminated or downstream calls dispose().

onTerminateDetach() - Method in class io.reactivex.rxjava3.core.Single

Nulls out references to the upstream producer and downstream SingleObserver if the sequence is terminated or downstream calls dispose().

P

parallel() - Method in class io.reactivex.rxjava3.core.Flowable

Parallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) and dispatches the upstream items to them in a round-robin fashion.

parallel(int) - Method in class io.reactivex.rxjava3.core.Flowable

Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion.

parallel(int, int) - Method in class io.reactivex.rxjava3.core.Flowable

Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion and uses the defined per-'rail' prefetch amount.

ParallelFailureHandling - Enum in io.reactivex.rxjava3.parallel

Enumerations for handling failure within a parallel operator.

ParallelFlowable<T> - Class in io.reactivex.rxjava3.parallel

Abstract base class for parallel publishing of events signaled to an array of Subscribers.

ParallelFlowable() - Constructor for class io.reactivex.rxjava3.parallel.ParallelFlowable

ParallelFlowableConverter<T,R> - Interface in io.reactivex.rxjava3.parallel

Convenience interface and callback used by the ParallelFlowable.to(io.reactivex.rxjava3.parallel.ParallelFlowableConverter) operator to turn a ParallelFlowable into another value fluently.

parallelism() - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Returns the number of expected parallel Subscribers.

ParallelTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.parallel

Interface to compose ParallelFlowable.

peek() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

Returns the next element in this queue without removing it or null if this queue is empty

poll() - Method in interface io.reactivex.rxjava3.operators.SimplePlainQueue

poll() - Method in interface io.reactivex.rxjava3.operators.SimpleQueue

Tries to dequeue a value (non-null) or returns null if the queue is empty.

poll() - Method in class io.reactivex.rxjava3.operators.SpscArrayQueue

poll() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

Tries to dequeue a value (non-null) or returns null if the queue is empty.

Predicate<T> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that returns true or false for the given input value.

printStackTrace() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

All of the following printStackTrace functionality is derived from JDK Throwable printStackTrace.

printStackTrace(PrintStream) - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

printStackTrace(PrintWriter) - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

propagate(Throwable) - Static method in class io.reactivex.rxjava3.exceptions.Exceptions

Convenience method to throw a RuntimeException and Error directly or wrap any other exception type into a RuntimeException.

ProtocolViolationException - Exception in io.reactivex.rxjava3.exceptions

Explicitly named exception to indicate a Reactive-Streams protocol violation.

ProtocolViolationException(String) - Constructor for exception io.reactivex.rxjava3.exceptions.ProtocolViolationException

Creates an instance with the given message.

publish() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable, which is a variety of Publisher that waits until its connect method is called before it begins emitting items to those Subscribers that have subscribed to it.

publish(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.

publish(Function, ? extends Publisher>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the underlying sequence.

publish(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable, which is a variety of Publisher that waits until its connect method is called before it begins emitting items to those Subscribers that have subscribed to it.

publish() - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable, which is a variety of ObservableSource that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.

publish(Function, ? extends ObservableSource>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable sequence.

PublishProcessor<T> - Class in io.reactivex.rxjava3.processors

Processor that multicasts all subsequently observed items to its current Subscribers.

PublishSubject<T> - Class in io.reactivex.rxjava3.subjects

A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current or late Observers.

Q

QueueDisposable<T> - Interface in io.reactivex.rxjava3.operators

An interface extending SimpleQueue and Disposable and allows negotiating the fusion mode between subsequent operators of the Observable base reactive type.

QueueFuseable<T> - Interface in io.reactivex.rxjava3.operators

Represents a SimpleQueue plus the means and constants for requesting a fusion mode.

QueueOverflowException - Exception in io.reactivex.rxjava3.exceptions

Indicates an overflow happened because the upstream disregarded backpressure completely or Subscriber.onNext(Object) was called concurrently from multiple threads without synchronization.

QueueOverflowException() - Constructor for exception io.reactivex.rxjava3.exceptions.QueueOverflowException

Constructs a QueueOverflowException with the default message.

QueueOverflowException(String) - Constructor for exception io.reactivex.rxjava3.exceptions.QueueOverflowException

Constructs a QueueOverflowException with the given message but no cause.

QueueSubscription<T> - Interface in io.reactivex.rxjava3.operators

An interface extending SimpleQueue and Subscription and allows negotiating the fusion mode between subsequent operators of the Flowable base reactive type.

R

range(int, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a sequence of Integers within a specified range.

range(int, int) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a sequence of Integers within a specified range.

rangeLong(long, long) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a sequence of Longs within a specified range.

rangeLong(long, long) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a sequence of Longs within a specified range.

rebatchRequests(int) - Method in class io.reactivex.rxjava3.core.Flowable

Requests n initially from the upstream and then 75% of n subsequently after 75% of n values have been emitted to the downstream.

reduce(BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Maybe that applies a specified accumulator function to the first item emitted by the current Flowable, then feeds the result of that function along with the second item emitted by the current Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, and emits the final result from the final call to your function as its sole item.

reduce(R, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that applies a specified accumulator function to the first item emitted by the current Flowable and a specified seed value, then feeds the result of that function along with the second item emitted by the current Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, emitting the final result from the final call to your function as its sole item.

reduce(BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Maybe that applies a specified accumulator function to the first item emitted by the current Observable, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, and emits the final result from the final call to your function as its sole item.

reduce(R, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that applies a specified accumulator function to the first item emitted by the current Observable and a specified seed value, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.

reduce(BiFunction) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Reduces all values within a 'rail' and across 'rails' with a reducer function into one Flowable sequence.

reduce(Supplier, BiFunction) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.

reduceWith(Supplier, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that applies a specified accumulator function to the first item emitted by the current Flowable and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by the current Flowable into the same function, and so on until all items have been emitted by the current and finite Flowable, emitting the final result from the final call to your function as its sole item.

reduceWith(Supplier, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that applies a specified accumulator function to the first item emitted by the current Observable and a seed value derived from calling a specified seedSupplier, then feeds the result of that function along with the second item emitted by the current Observable into the same function, and so on until all items have been emitted by the current and finite Observable, emitting the final result from the final call to your function as its sole item.

refCount() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Returns a Flowable that stays connected to this ConnectableFlowable as long as there is at least one subscription to this ConnectableFlowable.

refCount(int) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect if all subscribers have unsubscribed.

refCount(long, TimeUnit) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.

refCount(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.

refCount(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.

refCount(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.

refCount() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Returns an Observable that stays connected to this ConnectableObservable as long as there is at least one subscription to this ConnectableObservable.

refCount(int) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Connects to the upstream ConnectableObservable if the number of subscribed observers reaches the specified count and disconnect if all Observers have unsubscribed.

refCount(long, TimeUnit) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Connects to the upstream ConnectableObservable if the number of subscribed observers reaches 1 and disconnect after the specified timeout if all Observers have unsubscribed.

refCount(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Connects to the upstream ConnectableObservable if the number of subscribed observers reaches 1 and disconnect after the specified timeout if all Observers have unsubscribed.

refCount(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Connects to the upstream ConnectableObservable if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if all Observers have unsubscribed.

refCount(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Connects to the upstream ConnectableObservable if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if all Observers have unsubscribed.

remove(Disposable) - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

Removes and disposes the given Disposable if it is part of this container.

remove(Disposable) - Method in interface io.reactivex.rxjava3.disposables.DisposableContainer

Removes and disposes the given disposable if it is part of this container.

repeat() - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that repeatedly subscribes to this Completable until disposed.

repeat(long) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that subscribes repeatedly at most the given number of times to this Completable.

repeat() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that repeats the sequence of items emitted by the current Flowable indefinitely.

repeat(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that repeats the sequence of items emitted by the current Flowable at most count times.

repeat() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that repeats the sequence of items emitted by the current Maybe indefinitely.

repeat(long) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that repeats the sequence of items emitted by the current Maybe at most count times.

repeat() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that repeats the sequence of items emitted by the current Observable indefinitely.

repeat(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that repeats the sequence of items emitted by the current Observable at most count times.

repeat() - Method in class io.reactivex.rxjava3.core.Single

Repeatedly re-subscribes to the current Single and emits each success value as a Flowable sequence.

repeat(long) - Method in class io.reactivex.rxjava3.core.Single

Re-subscribes to the current Single at most the given number of times and emits each success value as a Flowable sequence.

repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that repeatedly subscribes to this Completable so long as the given stop BooleanSupplier returns false.

repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that repeats the sequence of items emitted by the current Flowable until the provided stop function returns true.

repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that repeats the sequence of items emitted by the current Maybe until the provided stop function returns true.

repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that repeats the sequence of items emitted by the current Observable until the provided stop function returns true.

repeatUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Single

Re-subscribes to the current Single until the given BooleanSupplier returns true and emits the success items as a Flowable sequence.

repeatWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that repeats when the Publisher returned by the handler Function emits an item or completes when this Publisher emits an onComplete event.

repeatWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the same values as the current Flowable with the exception of an onComplete.

repeatWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable that emits the same values as the current Maybe with the exception of an onComplete.

repeatWhen(Function, ? extends ObservableSource>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the same values as the current Observable with the exception of an onComplete.

repeatWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Single

Re-subscribes to the current Single if the Publisher returned by the handler function signals a value in response to a value signaled through the Flowable the handler receives.

replace(Disposable) - Method in class io.reactivex.rxjava3.disposables.SerialDisposable

Atomically: set the next disposable on this container but don't dispose the previous one (if any) or dispose next if the container has been disposed.

replay() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the underlying Publisher that will replay all of its items and notifications to any future Subscriber.

replay(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable.

replay(Function, ? extends Publisher>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.

replay(Function, ? extends Publisher>, int, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying bufferSize notifications.

replay(Function, ? extends Publisher>, int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.

replay(Function, ? extends Publisher>, int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.

replay(Function, ? extends Publisher>, int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.

replay(Function, ? extends Publisher>, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.

replay(Function, ? extends Publisher>, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.

replay(Function, ? extends Publisher>, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.

replay(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays at most bufferSize items to late Subscribers.

replay(int, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays at most bufferSize items to late Subscribers.

replay(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays at most bufferSize items that were emitted during a specified time window.

replay(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers.

replay(int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers.

replay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays all items emitted by it within a specified time window to late Subscribers.

replay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays all items emitted by it within a specified time window to late Subscribers.

replay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays all items emitted by it within a specified time window to late Subscribers.

replay() - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable that will replay all of its items and notifications to any future Observer.

replay(Function, ? extends ObservableSource>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on the items emitted by a ConnectableObservable that shares a single subscription to the current Observable.

replay(Function, ? extends ObservableSource>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.

replay(Function, ? extends ObservableSource>, int, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying bufferSize notifications.

replay(Function, ? extends ObservableSource>, int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.

replay(Function, ? extends ObservableSource>, int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.

replay(Function, ? extends ObservableSource>, int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.

replay(Function, ? extends ObservableSource>, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.

replay(Function, ? extends ObservableSource>, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.

replay(Function, ? extends ObservableSource>, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.

replay(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable that replays at most bufferSize items emitted by the current Observable.

replay(int, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable that replays at most bufferSize items emitted by the current Observable.

replay(int, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays at most bufferSize items that were emitted during a specified time window.

replay(int, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window.

replay(int, long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window.

replay(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.

replay(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.

replay(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.

ReplayProcessor<T> - Class in io.reactivex.rxjava3.processors

Replays events to Subscribers.

ReplaySubject<T> - Class in io.reactivex.rxjava3.subjects

Replays events (in a configurable bounded or unbounded manner) to current and late Observers.

request(long) - Method in class io.reactivex.rxjava3.subscribers.DefaultSubscriber

Requests from the upstream Subscription.

request(long) - Method in class io.reactivex.rxjava3.subscribers.DisposableSubscriber

Requests the specified amount from the upstream if its Subscription is set via onSubscribe already.

request(long) - Method in class io.reactivex.rxjava3.subscribers.ResourceSubscriber

Request the specified amount of elements from upstream.

request(long) - Method in class io.reactivex.rxjava3.subscribers.SafeSubscriber

request(long) - Method in class io.reactivex.rxjava3.subscribers.SerializedSubscriber

request(long) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

requested() - Method in interface io.reactivex.rxjava3.core.FlowableEmitter

The current outstanding request amount.

requestFusion(int) - Method in interface io.reactivex.rxjava3.operators.QueueFuseable

Request a fusion mode from the upstream.

requestMore(long) - Method in class io.reactivex.rxjava3.subscribers.TestSubscriber

Calls TestSubscriber.request(long) and returns this.

reset() - Method in class io.reactivex.rxjava3.flowables.ConnectableFlowable

Resets this ConnectableFlowable into its fresh state if it has terminated.

reset() - Method in class io.reactivex.rxjava3.observables.ConnectableObservable

Resets this ConnectableObservable into its fresh state if it has terminated or has been disposed.

reset() - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Removes all handlers and resets to default behavior.

ResourceCompletableObserver - Class in io.reactivex.rxjava3.observers

An abstract CompletableObserver that allows asynchronous cancellation of its subscription and associated resources.

ResourceCompletableObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceCompletableObserver

ResourceMaybeObserver<T> - Class in io.reactivex.rxjava3.observers

An abstract MaybeObserver that allows asynchronous cancellation of its subscription and associated resources.

ResourceMaybeObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceMaybeObserver

ResourceObserver<T> - Class in io.reactivex.rxjava3.observers

An abstract Observer that allows asynchronous cancellation of its subscription and associated resources.

ResourceObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceObserver

ResourceSingleObserver<T> - Class in io.reactivex.rxjava3.observers

An abstract SingleObserver that allows asynchronous cancellation of its subscription and the associated resources.

ResourceSingleObserver() - Constructor for class io.reactivex.rxjava3.observers.ResourceSingleObserver

ResourceSubscriber<T> - Class in io.reactivex.rxjava3.subscribers

An abstract Subscriber that allows asynchronous cancellation of its subscription and associated resources.

ResourceSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.ResourceSubscriber

retry() - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that retries this Completable as long as it emits an onError event.

retry(BiPredicate) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.

retry(long) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that when this Completable emits an error, retries at most the given number of times before giving up and emitting the last error.

retry(long, Predicate) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that when this Completable emits an error, retries at most times or until the predicate returns false, whichever happens first and emitting the last error.

retry(Predicate) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that when this Completable emits an error, calls the given predicate with the latest Throwable to decide whether to resubscribe to the upstream or not.

retry() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError (infinite retry count).

retry(BiPredicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.

retry(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, resubscribing to it if it calls onError up to a specified number of retries.

retry(long, Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Retries at most times or until the predicate returns false, whichever happens first.

retry(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Retries the current Flowable if the predicate returns true.

retry() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError (infinite retry count).

retry(BiPredicate) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.

retry(long) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe, resubscribing to it if it calls onError up to a specified number of retries.

retry(long, Predicate) - Method in class io.reactivex.rxjava3.core.Maybe

Retries at most times or until the predicate returns false, whichever happens first.

retry(Predicate) - Method in class io.reactivex.rxjava3.core.Maybe

Retries the current Maybe if it fails and the predicate returns true.

retry() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError (infinite retry count).

retry(BiPredicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError and the predicate returns true for that specific exception and retry count.

retry(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, resubscribing to it if it calls onError up to a specified number of retries.

retry(long, Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Retries at most times or until the predicate returns false, whichever happens first.

retry(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Retries the current Observable if the predicate returns true.

retry() - Method in class io.reactivex.rxjava3.core.Single

Repeatedly re-subscribes to the current Single indefinitely if it fails with an onError.

retry(long) - Method in class io.reactivex.rxjava3.core.Single

Repeatedly re-subscribe at most the specified times to the current Single if it fails with an onError.

retry(BiPredicate) - Method in class io.reactivex.rxjava3.core.Single

Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.

retry(long, Predicate) - Method in class io.reactivex.rxjava3.core.Single

Repeatedly re-subscribe at most times or until the predicate returns false, whichever happens first if it fails with an onError.

retry(Predicate) - Method in class io.reactivex.rxjava3.core.Single

Re-subscribe to the current Single if the given predicate returns true when the Single fails with an onError.

retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Completable

Retries until the given stop function returns true.

retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Flowable

Retries until the given stop function returns true.

retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Maybe

Retries until the given stop function returns true.

retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Observable

Retries until the given stop function returns true.

retryUntil(BooleanSupplier) - Method in class io.reactivex.rxjava3.core.Single

Retries until the given stop function returns true.

retryWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.

retryWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the same values as the current Flowable with the exception of an onError.

retryWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the same values as the current Maybe with the exception of an onError.

retryWhen(Function, ? extends ObservableSource>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the same values as the current Observable with the exception of an onError.

retryWhen(Function, ? extends Publisher>) - Method in class io.reactivex.rxjava3.core.Single

Re-subscribes to the current Single if and when the Publisher returned by the handler function signals a value.

run() - Method in interface io.reactivex.rxjava3.functions.Action

Runs the action and optionally throws a checked exception.

runOn(Scheduler) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with no work-stealing and default prefetch amount.

runOn(Scheduler, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with possibly work-stealing and a given prefetch amount.

RxJavaPlugins - Class in io.reactivex.rxjava3.plugins

Utility class to inject handlers to certain standard RxJava operations.

S

SafeObserver<T> - Class in io.reactivex.rxjava3.observers

Wraps another Observer and ensures all onXXX methods conform the protocol (except the requirement for serialized access).

SafeObserver(Observer) - Constructor for class io.reactivex.rxjava3.observers.SafeObserver

Constructs a SafeObserver by wrapping the given actual Observer.

safeSubscribe(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable

Wraps the given CompletableObserver, catches any RuntimeExceptions thrown by its CompletableObserver.onSubscribe(Disposable), CompletableObserver.onError(Throwable) or CompletableObserver.onComplete() methods and routes those to the global error handler via RxJavaPlugins.onError(Throwable).

safeSubscribe(Subscriber) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and wraps the given Subscriber into a SafeSubscriber (if not already a SafeSubscriber) that deals with exceptions thrown by a misbehaving Subscriber (that doesn't follow the Reactive Streams specification).

safeSubscribe(MaybeObserver) - Method in class io.reactivex.rxjava3.core.Maybe

Wraps the given MaybeObserver, catches any RuntimeExceptions thrown by its MaybeObserver.onSubscribe(Disposable), MaybeObserver.onSuccess(Object), MaybeObserver.onError(Throwable) or MaybeObserver.onComplete() methods and routes those to the global error handler via RxJavaPlugins.onError(Throwable).

safeSubscribe(Observer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the current Observable and wraps the given Observer into a SafeObserver (if not already a SafeObserver) that deals with exceptions thrown by a misbehaving Observer (that doesn't follow the Reactive Streams specification).

safeSubscribe(SingleObserver) - Method in class io.reactivex.rxjava3.core.Single

Wraps the given SingleObserver, catches any RuntimeExceptions thrown by its SingleObserver.onSubscribe(Disposable), SingleObserver.onSuccess(Object) or SingleObserver.onError(Throwable) methods* and routes those to the global error handler via RxJavaPlugins.onError(Throwable).

SafeSubscriber<T> - Class in io.reactivex.rxjava3.subscribers

Wraps another Subscriber and ensures all onXXX methods conform the protocol (except the requirement for serialized access).

SafeSubscriber(Subscriber) - Constructor for class io.reactivex.rxjava3.subscribers.SafeSubscriber

Constructs a SafeSubscriber by wrapping the given actual Subscriber.

sample(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals.

sample(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals and optionally emit the very last upstream item when the upstream completes.

sample(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler.

sample(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.

sample(long, TimeUnit, Scheduler, boolean, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.

sample(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that, when the specified sampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the current Flowable since the previous emission from the sampler Publisher.

sample(Publisher, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that, when the specified sampler Publisher emits an item or completes, emits the most recently emitted item (if any) emitted by the current Flowable since the previous emission from the sampler Publisher and optionally emit the very last upstream item when the upstream or other Publisher complete.

sample(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals.

sample(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals and optionally emit the very last upstream item when the upstream completes.

sample(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.

sample(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.

sample(long, TimeUnit, Scheduler, boolean, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.

sample(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource.

sample(ObservableSource, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that, when the specified sampler ObservableSource emits an item or completes, emits the most recently emitted item (if any) emitted by the current Observable since the previous emission from the sampler ObservableSource and optionally emit the very last upstream item when the upstream or other ObservableSource complete.

ScalarSupplier<T> - Interface in io.reactivex.rxjava3.operators

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.

scan(BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the first value emitted by the current Flowable, then emits one value for each subsequent value emitted by the current Flowable.

scan(R, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Flowable.

scan(BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the first value emitted by the current Observable, then emits one value for each subsequent value emitted by the current Observable.

scan(R, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Observable.

scanWith(Supplier, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Flowable.

scanWith(Supplier, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the provided initial (seed) value, then emits one value for each value emitted by the current Observable.

schedule(Runnable) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker

Schedules a Runnable for execution without any time delay.

schedule(Runnable, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker

Schedules an Runnable for execution at some point in the future specified by a time delay relative to the current time.

scheduleDirect(Runnable) - Method in class io.reactivex.rxjava3.core.Scheduler

Schedules the given task on this Scheduler without any time delay.

scheduleDirect(Runnable, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler

Schedules the execution of the given task with the given time delay.

schedulePeriodically(Runnable, long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler.Worker

Schedules a periodic execution of the given task with the given initial time delay and repeat period.

schedulePeriodicallyDirect(Runnable, long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Scheduler

Schedules a periodic execution of the given task with the given initial time delay and repeat period.

Scheduler - Class in io.reactivex.rxjava3.core

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.

Scheduler() - Constructor for class io.reactivex.rxjava3.core.Scheduler

Scheduler.Worker - Class in io.reactivex.rxjava3.core

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

SchedulerRunnableIntrospection - Interface in io.reactivex.rxjava3.schedulers

Interface to indicate the implementor class wraps a Runnable that can be accessed via SchedulerRunnableIntrospection.getWrappedRunnable().

Schedulers - Class in io.reactivex.rxjava3.schedulers

Static factory methods for returning standard Scheduler instances.

SchedulerSupport - Annotation Type in io.reactivex.rxjava3.annotations

Indicates what kind of scheduler the class or method uses.

sequenceEqual(CompletableSource, CompletableSource) - Static method in class io.reactivex.rxjava3.core.Completable

Compares two CompletableSources and emits true via a Single if both complete.

sequenceEqual(Publisher, Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.

sequenceEqual(Publisher, Publisher, BiPredicate) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

sequenceEqual(Publisher, Publisher, BiPredicate, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise based on the results of a specified equality function.

sequenceEqual(Publisher, Publisher, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a Boolean value that indicates whether two Publisher sequences are the same by comparing the items emitted by each Publisher pairwise.

sequenceEqual(MaybeSource, MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that emits a Boolean value that indicates whether two MaybeSource sequences are the same by comparing the items emitted by each MaybeSource pairwise.

sequenceEqual(MaybeSource, MaybeSource, BiPredicate) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that emits a Boolean value that indicates whether two MaybeSources are the same by comparing the items emitted by each MaybeSource pairwise based on the results of a specified equality function.

sequenceEqual(ObservableSource, ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.

sequenceEqual(ObservableSource, ObservableSource, BiPredicate) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.

sequenceEqual(ObservableSource, ObservableSource, BiPredicate, int) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise based on the results of a specified equality function.

sequenceEqual(ObservableSource, ObservableSource, int) - Static method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a Boolean value that indicates whether two ObservableSource sequences are the same by comparing the items emitted by each ObservableSource pairwise.

sequenceEqual(SingleSource, SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Compares two SingleSources and emits true if they emit the same value (compared via Object.equals(Object)).

sequential() - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails.

sequential(int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails.

sequentialDelayError() - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.

sequentialDelayError(int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.

SerialDisposable - Class in io.reactivex.rxjava3.disposables

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.

SerialDisposable() - Constructor for class io.reactivex.rxjava3.disposables.SerialDisposable

Constructs an empty SerialDisposable.

SerialDisposable(Disposable) - Constructor for class io.reactivex.rxjava3.disposables.SerialDisposable

Constructs a SerialDisposable with the given initial Disposable instance.

serialize() - Method in class io.reactivex.rxjava3.core.Flowable

Forces the current Flowable's emissions and notifications to be serialized and for it to obey the Publisher contract in other ways.

serialize() - Method in interface io.reactivex.rxjava3.core.FlowableEmitter

Ensures that calls to onNext, onError and onComplete are properly serialized.

serialize() - Method in class io.reactivex.rxjava3.core.Observable

Forces the current Observable's emissions and notifications to be serialized and for it to obey the ObservableSource contract in other ways.

serialize() - Method in interface io.reactivex.rxjava3.core.ObservableEmitter

Ensures that calls to onNext, onError and onComplete are properly serialized.

SerializedObserver<T> - Class in io.reactivex.rxjava3.observers

Serializes access to the Observer.onNext(Object), Observer.onError(Throwable) and Observer.onComplete() methods of another Observer.

SerializedObserver(Observer) - Constructor for class io.reactivex.rxjava3.observers.SerializedObserver

Construct a SerializedObserver by wrapping the given actual Observer.

SerializedObserver(Observer, boolean) - Constructor for class io.reactivex.rxjava3.observers.SerializedObserver

Construct a SerializedObserver by wrapping the given actual Observer and optionally delaying the errors till all regular values have been emitted from the internal buffer.

SerializedSubscriber<T> - Class in io.reactivex.rxjava3.subscribers

Serializes access to the Subscriber.onNext(Object), Subscriber.onError(Throwable) and Subscriber.onComplete() methods of another Subscriber.

SerializedSubscriber(Subscriber) - Constructor for class io.reactivex.rxjava3.subscribers.SerializedSubscriber

Construct a SerializedSubscriber by wrapping the given actual Subscriber.

SerializedSubscriber(Subscriber, boolean) - Constructor for class io.reactivex.rxjava3.subscribers.SerializedSubscriber

Construct a SerializedSubscriber by wrapping the given actual Subscriber and optionally delaying the errors till all regular values have been emitted from the internal buffer.

set(Disposable) - Method in class io.reactivex.rxjava3.disposables.SerialDisposable

Atomically: set the next disposable on this container and dispose the previous one (if any) or dispose next if the container has been disposed.

setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter

Sets a Cancellable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.FlowableEmitter

Sets a Cancellable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Sets a Cancellable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.ObservableEmitter

Sets a Cancellable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setCancellable(Cancellable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter

Sets a Cancellable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setComputationSchedulerHandler(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter

Sets a Disposable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.FlowableEmitter

Sets a Disposable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Sets a Disposable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.ObservableEmitter

Sets a Disposable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setDisposable(Disposable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter

Sets a Disposable on this emitter; any previous Disposable or Cancellable will be disposed/cancelled.

setErrorHandler(Consumer) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setFailOnNonBlockingScheduler(boolean) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Enables or disables the blockingX operators to fail with an IllegalStateException on a non-blocking scheduler such as computation or single.

setInitComputationSchedulerHandler(Function, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setInitIoSchedulerHandler(Function, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setInitNewThreadSchedulerHandler(Function, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setInitSingleSchedulerHandler(Function, ? extends Scheduler>) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setIoSchedulerHandler(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setNewThreadSchedulerHandler(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnBeforeBlocking(BooleanSupplier) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Set the handler that is called when an operator attempts a blocking await; the handler should return true to prevent the blocking and to signal an IllegalStateException instead.

setOnCompletableAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnCompletableSubscribe(BiFunction) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnConnectableFlowableAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnConnectableObservableAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnFlowableAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnFlowableSubscribe(BiFunction) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnMaybeAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnMaybeSubscribe(BiFunction) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnObservableAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnObservableSubscribe(BiFunction) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnParallelAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnParallelSubscribe(BiFunction) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnSingleAssembly(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setOnSingleSubscribe(BiFunction) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setScheduleHandler(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

setSingleSchedulerHandler(Function) - Static method in class io.reactivex.rxjava3.plugins.RxJavaPlugins

Sets the specific hook function.

share() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable that multicasts (and shares a single subscription to) the current Flowable.

share() - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable that multicasts (and shares a single subscription to) the current Observable.

shutdown() - Method in class io.reactivex.rxjava3.core.Scheduler

Instructs the Scheduler instance to stop threads, stop accepting tasks on any outstanding Scheduler.Worker instances and clean up any associated resources with this Scheduler.

shutdown() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Shuts down the standard Schedulers.

SimplePlainQueue<T> - Interface in io.reactivex.rxjava3.operators

Override of the SimpleQueue interface with no throws Throwable on poll().

SimpleQueue<T> - Interface in io.reactivex.rxjava3.operators

A simplified interface for offering, polling and clearing a queue.

SINGLE - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

The operator/class runs on RxJava's single scheduler or takes timing information from it.

single(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits the single item emitted by the current Flowable if it emits only a single item, or a default item if the current Flowable emits no items.

single(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits the single item emitted by the current Observable, if the current Observable emits only a single item, or a default item if the current Observable emits no items.

Single<T> - Class in io.reactivex.rxjava3.core

The Single class implements the Reactive Pattern for a single value response.

Single() - Constructor for class io.reactivex.rxjava3.core.Single

single() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Returns a default, shared, single-thread-backed Scheduler instance for work requiring strongly-sequential execution on the same background thread.

SingleConverter<T,R> - Interface in io.reactivex.rxjava3.core

Convenience interface and callback used by the Single.to(io.reactivex.rxjava3.core.SingleConverter) operator to turn a Single into another value fluently.

singleElement() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Maybe that completes if this Flowable is empty, signals one item if this Flowable signals exactly one item or signals an IllegalArgumentException if this Flowable signals more than one item.

singleElement() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Maybe that completes if the current Observable is empty or emits the single item emitted by the current Observable, or signals an IllegalArgumentException if the current Observable emits more than one item.

SingleEmitter<T> - Interface in io.reactivex.rxjava3.core

Abstraction over an RxJava SingleObserver that allows associating a resource with it.

SingleObserver<T> - Interface in io.reactivex.rxjava3.core

Provides a mechanism for receiving push-based notification of a single value or an error.

SingleOnSubscribe<T> - Interface in io.reactivex.rxjava3.core

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 in io.reactivex.rxjava3.core

Interface to map/wrap a downstream SingleObserver to an upstream SingleObserver.

singleOrError() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits the single item emitted by this Flowable, if this Flowable emits only a single item, otherwise if this Flowable completes without emitting any items a NoSuchElementException will be signaled and if this Flowable emits more than one item, an IllegalArgumentException will be signaled.

singleOrError() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits the single item emitted by the current Observable if it emits only a single item, otherwise if the current Observable completes without emitting any items or emits more than one item a NoSuchElementException or IllegalArgumentException will be signaled respectively.

singleOrErrorStage() - Method in class io.reactivex.rxjava3.core.Flowable

Signals the only expected upstream item, a NoSuchElementException if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.

singleOrErrorStage() - Method in class io.reactivex.rxjava3.core.Observable

Signals the only expected upstream item, a NoSuchElementException if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.

SingleSource<T> - Interface in io.reactivex.rxjava3.core

Represents a basic Single source base interface, consumable via an SingleObserver.

singleStage(T) - Method in class io.reactivex.rxjava3.core.Flowable

Signals the only expected upstream item (or the default item if the upstream is empty) or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.

singleStage(T) - Method in class io.reactivex.rxjava3.core.Observable

Signals the only expected upstream item (or the default item if the upstream is empty) or signals IllegalArgumentException if the upstream has more than one item via a CompletionStage.

SingleSubject<T> - Class in io.reactivex.rxjava3.subjects

Represents a hot Single-like source and consumer of events similar to Subjects.

SingleTransformer<Upstream,Downstream> - Interface in io.reactivex.rxjava3.core

Interface to compose Singles.

size() - Method in class io.reactivex.rxjava3.disposables.CompositeDisposable

Returns the number of currently held Disposables.

size() - Method in exception io.reactivex.rxjava3.exceptions.CompositeException

Returns the number of suppressed exceptions.

size() - Method in class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

Returns the number of elements in the queue.

skip(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that skips the first count items emitted by the current Flowable and emits the remainder.

skip(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that skips values emitted by the current Flowable before a specified time window elapses.

skip(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that skips values emitted by the current Flowable before a specified time window on a specified Scheduler elapses.

skip(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that skips the first count items emitted by the current Observable and emits the remainder.

skip(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that skips values emitted by the current Observable before a specified time window elapses.

skip(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that skips values emitted by the current Observable before a specified time window on a specified Scheduler elapses.

skipLast(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that drops a specified number of items from the end of the sequence emitted by the current Flowable.

skipLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that drops items emitted by the current Flowable during a specified time window before the source completes.

skipLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that drops items emitted by the current Flowable during a specified time window before the source completes.

skipLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.

skipLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.

skipLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.

skipLast(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that drops a specified number of items from the end of the sequence emitted by the current Observable.

skipLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that drops items emitted by the current Observable during a specified time window before the source completes.

skipLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that drops items emitted by the current Observable during a specified time window before the source completes.

skipLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.

skipLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.

skipLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.

skipUntil(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that skips items emitted by the current Flowable until a second Publisher emits an item.

skipUntil(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that skips items emitted by the current Observable until a second ObservableSource emits an item.

skipWhile(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that skips all items emitted by the current Flowable as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

skipWhile(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that skips all items emitted by the current Observable as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

sorted() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the events emitted by source Publisher, in a sorted order.

sorted(Comparator) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the events emitted by source Publisher, in a sorted order based on a specified comparison function.

sorted() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the events emitted by the current Observable, in a sorted order.

sorted(Comparator) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the events emitted by the current Observable, in a sorted order based on a specified comparison function.

sorted(Comparator) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.

sorted(Comparator, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.

SpscArrayQueue<E> - Class in io.reactivex.rxjava3.operators

A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.

SpscArrayQueue(int) - Constructor for class io.reactivex.rxjava3.operators.SpscArrayQueue

Constructs an array-backed queue with the given capacity rounded up to the next power of 2 size.

SpscLinkedArrayQueue<T> - Class in io.reactivex.rxjava3.operators

A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower than the producer.

SpscLinkedArrayQueue(int) - Constructor for class io.reactivex.rxjava3.operators.SpscLinkedArrayQueue

Constructs a linked array-based queue instance with the given island size rounded up to the next power of 2.

start() - Method in class io.reactivex.rxjava3.core.Scheduler

Allows the Scheduler instance to start threads and accept tasks on them.

start() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

Initializes this Processor by setting an upstream Subscription that ignores request amounts, uses a fixed buffer and allows using the onXXX and offer methods afterwards.

start() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Starts the standard Schedulers.

startUnbounded() - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

Initializes this Processor by setting an upstream Subscription that ignores request amounts, uses an unbounded buffer and allows using the onXXX and offer methods afterwards.

startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which first runs the other CompletableSource then the current Completable if the other completed normally.

startWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Flowable which first runs the other SingleSource then the current Completable if the other succeeded normally.

startWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Flowable which first runs the other MaybeSource then the current Completable if the other succeeded or completed normally.

startWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns an Observable which first delivers the events of the other ObservableSource then runs the current Completable.

startWith(Publisher) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Flowable which first delivers the events of the other Publisher then runs the current Completable.

startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable which first runs the other CompletableSource then the current Flowable if the other completed normally.

startWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable which first runs the other SingleSource then the current Flowable if the other succeeded normally.

startWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable which first runs the other MaybeSource then the current Flowable if the other succeeded or completed normally.

startWith(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items in a specified Publisher before it begins to emit items emitted by the current Flowable.

startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable which first runs the other CompletableSource then the current Maybe if the other completed normally.

startWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable which first runs the other SingleSource then the current Maybe if the other succeeded normally.

startWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable which first runs the other MaybeSource then the current Maybe if the other succeeded or completed normally.

startWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns an Observable which first delivers the events of the other ObservableSource then runs the current Maybe.

startWith(Publisher) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Flowable which first delivers the events of the other Publisher then runs the current Maybe.

startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable which first runs the other CompletableSource then the current Observable if the other completed normally.

startWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable which first runs the other SingleSource then the current Observable if the other succeeded normally.

startWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable which first runs the other MaybeSource then the current Observable if the other succeeded or completed normally.

startWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items in a specified ObservableSource before it begins to emit items emitted by the current Observable.

startWith(CompletableSource) - Method in class io.reactivex.rxjava3.core.Single

Returns a Flowable which first runs the other CompletableSource then the current Single if the other completed normally.

startWith(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Returns a Flowable which first runs the other SingleSource then the current Single if the other succeeded normally.

startWith(MaybeSource) - Method in class io.reactivex.rxjava3.core.Single

Returns a Flowable which first runs the other MaybeSource then the current Single if the other succeeded or completed normally.

startWith(ObservableSource) - Method in class io.reactivex.rxjava3.core.Single

Returns an Observable which first delivers the events of the other ObservableSource then runs the current Single.

startWith(Publisher) - Method in class io.reactivex.rxjava3.core.Single

Returns a Flowable which first delivers the events of the other Publisher then runs the current Single.

startWithArray(T...) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the specified items before it begins to emit items emitted by the current Flowable.

startWithArray(T...) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the specified items before it begins to emit items emitted by the current Observable.

startWithItem(T) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits a specified item before it begins to emit items emitted by the current Flowable.

startWithItem(T) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits a specified item before it begins to emit items emitted by the current Observable.

startWithIterable(Iterable) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items in a specified Iterable before it begins to emit items emitted by the current Flowable.

startWithIterable(Iterable) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the current Observable.

Subject<T> - Class in io.reactivex.rxjava3.subjects

Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Observers.

Subject() - Constructor for class io.reactivex.rxjava3.subjects.Subject

subscribe() - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to this Completable and returns a Disposable which can be used to dispose the subscription.

subscribe(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable

subscribe(Action, Consumer) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to this Completable and calls back either the onError or onComplete functions.

subscribe(Action, Consumer, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Completable

Wraps the given onXXX callbacks into a Disposable CompletableObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the CompletableObserver is removed from the given composite.

subscribe(Action) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes to this Completable and calls the given Action when this Completable completes normally.

subscribe(CompletableEmitter) - Method in interface io.reactivex.rxjava3.core.CompletableOnSubscribe

Called for each CompletableObserver that subscribes.

subscribe(CompletableObserver) - Method in interface io.reactivex.rxjava3.core.CompletableSource

Subscribes the given CompletableObserver to this CompletableSource instance.

subscribe() - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and ignores onNext and onComplete emissions.

subscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and provides a callback to handle the items it emits.

subscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error notification it issues.

subscribe(Consumer, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error or completion notification it issues.

subscribe(Consumer, Consumer, Action, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Flowable

Wraps the given onXXX callbacks into a Disposable Subscriber, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the Subscriber is removed from the given container.

subscribe(Subscriber) - Method in class io.reactivex.rxjava3.core.Flowable

subscribe(FlowableSubscriber) - Method in class io.reactivex.rxjava3.core.Flowable

Establish a connection between this Flowable and the given FlowableSubscriber and start streaming events based on the demand of the FlowableSubscriber.

subscribe(FlowableEmitter) - Method in interface io.reactivex.rxjava3.core.FlowableOnSubscribe

Called for each Subscriber that subscribes.

subscribe() - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to a Maybe and ignores onSuccess and onComplete emissions.

subscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to a Maybe and provides a callback to handle the items it emits.

subscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.

subscribe(Consumer, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.

subscribe(Consumer, Consumer, Action, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Maybe

Wraps the given onXXX callbacks into a Disposable MaybeObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the MaybeObserver is removed from the given composite.

subscribe(MaybeObserver) - Method in class io.reactivex.rxjava3.core.Maybe

subscribe(MaybeEmitter) - Method in interface io.reactivex.rxjava3.core.MaybeOnSubscribe

Called for each MaybeObserver that subscribes.

subscribe(MaybeObserver) - Method in interface io.reactivex.rxjava3.core.MaybeSource

Subscribes the given MaybeObserver to this MaybeSource instance.

subscribe() - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the current Observable and ignores onNext and onComplete emissions.

subscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the current Observable and provides a callback to handle the items it emits.

subscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the current Observable and provides callbacks to handle the items it emits and any error notification it signals.

subscribe(Consumer, Consumer, Action) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes to the current Observable and provides callbacks to handle the items it emits and any error or completion notification it signals.

subscribe(Consumer, Consumer, Action, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Observable

Wraps the given onXXX callbacks into a Disposable Observer, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the Observer is removed from the given container.

subscribe(Observer) - Method in class io.reactivex.rxjava3.core.Observable

subscribe(ObservableEmitter) - Method in interface io.reactivex.rxjava3.core.ObservableOnSubscribe

Called for each Observer that subscribes.

subscribe(Observer) - Method in interface io.reactivex.rxjava3.core.ObservableSource

Subscribes the given Observer to this ObservableSource instance.

subscribe() - Method in class io.reactivex.rxjava3.core.Single

Subscribes to a Single but ignore its emission or notification.

subscribe(BiConsumer) - Method in class io.reactivex.rxjava3.core.Single

Subscribes to a Single and provides a composite callback to handle the item it emits or any error notification it issues.

subscribe(Consumer) - Method in class io.reactivex.rxjava3.core.Single

Subscribes to a Single and provides a callback to handle the item it emits.

subscribe(Consumer, Consumer) - Method in class io.reactivex.rxjava3.core.Single

Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.

subscribe(Consumer, Consumer, DisposableContainer) - Method in class io.reactivex.rxjava3.core.Single

Wraps the given onXXX callbacks into a Disposable SingleObserver, adds it to the given DisposableContainer and ensures, that if the upstream terminates or this particular Disposable is disposed, the SingleObserver is removed from the given container.

subscribe(SingleObserver) - Method in class io.reactivex.rxjava3.core.Single

subscribe(SingleEmitter) - Method in interface io.reactivex.rxjava3.core.SingleOnSubscribe

Called for each SingleObserver that subscribes.

subscribe(SingleObserver) - Method in interface io.reactivex.rxjava3.core.SingleSource

Subscribes the given SingleObserver to this SingleSource instance.

subscribe(Subscriber[]) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Subscribes an array of Subscribers to this ParallelFlowable and triggers the execution chain for all 'rails'.

subscribeActual(CompletableObserver) - Method in class io.reactivex.rxjava3.core.Completable

Implement this method to handle the incoming CompletableObservers and perform the business logic in your operator.

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.core.Flowable

Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Subscribers.

subscribeActual(MaybeObserver) - Method in class io.reactivex.rxjava3.core.Maybe

Implement this method in subclasses to handle the incoming MaybeObservers.

subscribeActual(Observer) - Method in class io.reactivex.rxjava3.core.Observable

Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming Observers.

subscribeActual(SingleObserver) - Method in class io.reactivex.rxjava3.core.Single

Implement this method in subclasses to handle the incoming SingleObservers.

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.processors.AsyncProcessor

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.processors.BehaviorProcessor

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.processors.MulticastProcessor

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.processors.PublishProcessor

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.processors.ReplayProcessor

subscribeActual(Subscriber) - Method in class io.reactivex.rxjava3.processors.UnicastProcessor

subscribeActual(Observer) - Method in class io.reactivex.rxjava3.subjects.AsyncSubject

subscribeActual(Observer) - Method in class io.reactivex.rxjava3.subjects.BehaviorSubject

subscribeActual(CompletableObserver) - Method in class io.reactivex.rxjava3.subjects.CompletableSubject

subscribeActual(MaybeObserver) - Method in class io.reactivex.rxjava3.subjects.MaybeSubject

subscribeActual(Observer) - Method in class io.reactivex.rxjava3.subjects.PublishSubject

subscribeActual(Observer) - Method in class io.reactivex.rxjava3.subjects.ReplaySubject

subscribeActual(SingleObserver) - Method in class io.reactivex.rxjava3.subjects.SingleSubject

subscribeActual(Observer) - Method in class io.reactivex.rxjava3.subjects.UnicastSubject

subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the Scheduler.

subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler.

subscribeOn(Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler optionally reroutes requests from other threads to the same Scheduler thread.

subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.

subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Asynchronously subscribes Observers to the current Observable on the specified Scheduler.

subscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.

subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Completable

Subscribes a given CompletableObserver (subclass) to this Completable and returns the given CompletableObserver as is.

subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Flowable

Subscribes a given Subscriber (subclass) to this Flowable and returns the given Subscriber as is.

subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Maybe

Subscribes a given MaybeObserver (subclass) to this Maybe and returns the given MaybeObserver as is.

subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Observable

Subscribes a given Observer (subclass) to the current Observable and returns the given Observer instance as is.

subscribeWith(E) - Method in class io.reactivex.rxjava3.core.Single

Subscribes a given SingleObserver (subclass) to this Single and returns the given SingleObserver as is.

Supplier<T> - Interface in io.reactivex.rxjava3.functions

A functional interface (callback) that provides a single value or throws an exception.

switchIfEmpty(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable or the items of an alternate Publisher if the current Flowable is empty.

switchIfEmpty(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the items emitted by the current Maybe or the items of an alternate MaybeSource if the current Maybe is empty.

switchIfEmpty(SingleSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Single that emits the items emitted by the current Maybe or the item of an alternate SingleSource if the current Maybe is empty.

switchIfEmpty(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable or the items of an alternate ObservableSource if the current Observable is empty.

switchMap(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.

switchMap(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers.

switchMap(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

switchMap(Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources.

switchMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Flowable

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.

switchMapCompletable(Function) - Method in class io.reactivex.rxjava3.core.Observable

Maps the items of the current Observable into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.

switchMapCompletableDelayError(Function) - Method in class io.reactivex.rxjava3.core.Flowable

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 and delaying any main or inner errors until all of them terminate.

switchMapCompletableDelayError(Function) - Method in class io.reactivex.rxjava3.core.Observable

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 and delaying any main or inner errors until all of them terminate.

switchMapDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.

switchMapDelayError(Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a new Flowable by applying a function that you supply to each item emitted by the current Flowable that returns a Publisher, and then emitting the items emitted by the most recently emitted of these Publishers and delays any error until all Publishers terminate.

switchMapDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.

switchMapDelayError(Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns an ObservableSource, and then emitting the items emitted by the most recently emitted of these ObservableSources and delays any error until all ObservableSources terminate.

switchMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if this Flowable or any of the active inner MaybeSources fail.

switchMapMaybe(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps the items of the current Observable into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available while failing immediately if the current Observable or any of the active inner MaybeSources fail.

switchMapMaybeDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from this Flowable or the inner MaybeSources until all terminate.

switchMapMaybeDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one if available, delaying errors from the current Observable or the inner MaybeSources until all terminate.

switchMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one while failing immediately if this Flowable or any of the active inner SingleSources fail.

switchMapSingle(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources.

switchMapSingleDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones (and ignoring their signals) and emits the latest success value of the current one, delaying errors from this Flowable or the inner SingleSources until all terminate.

switchMapSingleDelayError(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a new Observable by applying a function that you supply to each item emitted by the current Observable that returns a SingleSource, and then emitting the item emitted by the most recently emitted of these SingleSources and delays any error until all SingleSources terminate.

switchOnNext(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Switches between CompletableSources emitted by the source Publisher whenever a new CompletableSource is emitted, disposing the previously running CompletableSource, exposing the setup as a Completable sequence.

switchOnNext(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.

switchOnNext(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers.

switchOnNext(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Switches between MaybeSources emitted by the source Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence.

switchOnNext(ObservableSource>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.

switchOnNext(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources.

switchOnNext(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Switches between SingleSources emitted by the source Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence.

switchOnNextDelayError(Publisher) - Static method in class io.reactivex.rxjava3.core.Completable

Switches between CompletableSources emitted by the source Publisher whenever a new CompletableSource is emitted, disposing the previously running CompletableSource, exposing the setup as a Completable sequence and delaying all errors from all of them until all terminate.

switchOnNextDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.

switchOnNextDelayError(Publisher>, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Converts a Publisher that emits Publishers into a Publisher that emits the items emitted by the most recently emitted of those Publishers and delays any exception until all Publishers terminate.

switchOnNextDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Maybe

Switches between MaybeSources emitted by the source Publisher whenever a new MaybeSource is emitted, disposing the previously running MaybeSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.

switchOnNextDelayError(ObservableSource>) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.

switchOnNextDelayError(ObservableSource>, int) - Static method in class io.reactivex.rxjava3.core.Observable

Converts an ObservableSource that emits ObservableSources into an Observable that emits the items emitted by the most recently emitted of those ObservableSources and delays any exception until all ObservableSources terminate.

switchOnNextDelayError(Publisher>) - Static method in class io.reactivex.rxjava3.core.Single

Switches between SingleSources emitted by the source Publisher whenever a new SingleSource is emitted, disposing the previously running SingleSource, exposing the success items as a Flowable sequence and delaying all errors from all of them until all terminate.

SYNC - Static variable in interface io.reactivex.rxjava3.operators.QueueFuseable

Request a synchronous fusion mode and can be returned by QueueFuseable.requestFusion(int) for an accepted mode.

T

tag - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

The optional tag associated with this test consumer.

take(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the first count items emitted by the current Flowable.

take(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits those items emitted by source Publisher before a specified time runs out.

take(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a specified Scheduler) runs out.

take(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the first count items emitted by the current Observable.

take(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits those items emitted by the current Observable before a specified time runs out.

take(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits those items emitted by the current Observable before a specified time (on a specified Scheduler) runs out.

takeLast(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits at most the last count items emitted by the current Flowable.

takeLast(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.

takeLast(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a given Scheduler.

takeLast(long, long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a given Scheduler.

takeLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.

takeLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed.

takeLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.

takeLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.

takeLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.

takeLast(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits at most the last count items emitted by the current Observable.

takeLast(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed.

takeLast(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.

takeLast(long, long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.

takeLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed.

takeLast(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed.

takeLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.

takeLast(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.

takeLast(long, TimeUnit, Scheduler, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.

takeUntil(CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Terminates the downstream if this or the other Completable terminates (wins the termination race) while disposing the connection to the losing source.

takeUntil(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items emitted by the current Flowable, checks the specified predicate for each item, and then completes when the condition is satisfied.

takeUntil(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the items emitted by the current Flowable until a second Publisher emits an item or completes.

takeUntil(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the items emitted by the current Maybe until a second MaybeSource emits an item.

takeUntil(Publisher) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the item emitted by the current Maybe until a second Publisher emits an item.

takeUntil(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the items emitted by the current Observable until a second ObservableSource emits an item or completes.

takeUntil(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items emitted by the current Observable, checks the specified predicate for each item, and then completes when the condition is satisfied.

takeUntil(CompletableSource) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the item emitted by the current Single until a CompletableSource terminates.

takeUntil(Publisher) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the item emitted by the current Single until a Publisher emits an item or completes.

takeUntil(SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the item emitted by the current Single until a second Single emits an item.

takeWhile(Predicate) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items emitted by the current Flowable so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.

takeWhile(Predicate) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items emitted by the current Observable so long as each item satisfied a specified condition, and then completes as soon as this condition is not satisfied.

test() - Method in class io.reactivex.rxjava3.core.Completable

Creates a TestObserver and subscribes it to this Completable.

test(boolean) - Method in class io.reactivex.rxjava3.core.Completable

Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.

test() - Method in class io.reactivex.rxjava3.core.Flowable

Creates a TestSubscriber that requests Long.MAX_VALUE and subscribes it to this Flowable.

test(long) - Method in class io.reactivex.rxjava3.core.Flowable

Creates a TestSubscriber with the given initial request amount and subscribes it to this Flowable.

test(long, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Creates a TestSubscriber with the given initial request amount, optionally cancels it before the subscription and subscribes it to this Flowable.

test() - Method in class io.reactivex.rxjava3.core.Maybe

Creates a TestObserver and subscribes it to this Maybe.

test(boolean) - Method in class io.reactivex.rxjava3.core.Maybe

Creates a TestObserver optionally in cancelled state, then subscribes it to this Maybe.

test() - Method in class io.reactivex.rxjava3.core.Observable

Creates a TestObserver and subscribes it to the current Observable.

test(boolean) - Method in class io.reactivex.rxjava3.core.Observable

Creates a TestObserver, optionally disposes it and then subscribes it to the current Observable.

test() - Method in class io.reactivex.rxjava3.core.Single

Creates a TestObserver and subscribes it to this Single.

test(boolean) - Method in class io.reactivex.rxjava3.core.Single

Creates a TestObserver optionally in cancelled state, then subscribes it to this Single.

test(T1, T2) - Method in interface io.reactivex.rxjava3.functions.BiPredicate

Test the given input values and return a boolean.

test(T) - Method in interface io.reactivex.rxjava3.functions.Predicate

Test the given input value and return a boolean.

TestObserver<T> - Class in io.reactivex.rxjava3.observers

An Observer, MaybeObserver, SingleObserver and CompletableObserver composite that can record events from Observables, Maybes, Singles and Completables and allows making assertions about them.

TestObserver() - Constructor for class io.reactivex.rxjava3.observers.TestObserver

Constructs a non-forwarding TestObserver.

TestObserver(Observer) - Constructor for class io.reactivex.rxjava3.observers.TestObserver

Constructs a forwarding TestObserver.

TestScheduler - Class in io.reactivex.rxjava3.schedulers

A special, non thread-safe scheduler for testing operators that require a scheduler without introducing real concurrency and allows manually advancing a virtual time.

TestScheduler() - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler

Creates a new TestScheduler with initial virtual time of zero.

TestScheduler(boolean) - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler

Creates a new TestScheduler with the option to use the RxJavaPlugins.onSchedule(Runnable) hook when scheduling tasks.

TestScheduler(long, TimeUnit) - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler

Creates a new TestScheduler with the specified initial virtual time.

TestScheduler(long, TimeUnit, boolean) - Constructor for class io.reactivex.rxjava3.schedulers.TestScheduler

Creates a new TestScheduler with the specified initial virtual time and with the option to use the RxJavaPlugins.onSchedule(Runnable) hook when scheduling tasks.

TestSubscriber<T> - Class in io.reactivex.rxjava3.subscribers

A Subscriber implementation that records events and allows making assertions about them.

TestSubscriber() - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber

Constructs a non-forwarding TestSubscriber with an initial request value of Long.MAX_VALUE.

TestSubscriber(long) - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber

Constructs a non-forwarding TestSubscriber with the specified initial request value.

TestSubscriber(Subscriber) - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber

Constructs a forwarding TestSubscriber but leaves the requesting to the wrapped Subscriber.

TestSubscriber(Subscriber, long) - Constructor for class io.reactivex.rxjava3.subscribers.TestSubscriber

Constructs a forwarding TestSubscriber with the specified initial request amount and an actual Subscriber to forward events to.

throttleFirst(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration.

throttleFirst(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

throttleFirst(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

throttleFirst(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration.

throttleFirst(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

throttleFirst(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.

throttleLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration.

throttleLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

throttleLast(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

throttleLast(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration.

throttleLast(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

throttleLast(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.

throttleLatest(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, Scheduler, boolean, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.

throttleLatest(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, Scheduler, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.

throttleLatest(long, TimeUnit, Scheduler, boolean, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.

throttleWithTimeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires.

throttleWithTimeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.

throttleWithTimeout(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.

throttleWithTimeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires.

throttleWithTimeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.

throttleWithTimeout(long, TimeUnit, Scheduler, Consumer) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.

throwIfFatal(Throwable) - Static method in class io.reactivex.rxjava3.exceptions.Exceptions

Throws a particular Throwable only if it belongs to a set of "fatal" error varieties.

time() - Method in class io.reactivex.rxjava3.schedulers.Timed

Returns the time value.

time(TimeUnit) - Method in class io.reactivex.rxjava3.schedulers.Timed

Returns the contained time value in the time unit specified.

Timed<T> - Class in io.reactivex.rxjava3.schedulers

Holds onto a value along with time information.

Timed(T, long, TimeUnit) - Constructor for class io.reactivex.rxjava3.schedulers.Timed

Constructs a Timed instance with the given value and time information.

timeInterval() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.

timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.

timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable.

timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.

timeInterval() - Method in class io.reactivex.rxjava3.core.Maybe

Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.

timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.

timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe

Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.

timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.

timeInterval() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.

timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.

timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable.

timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.

timeInterval() - Method in class io.reactivex.rxjava3.core.Single

Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

timeInterval(Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

timeInterval(TimeUnit) - Method in class io.reactivex.rxjava3.core.Single

Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

timeInterval(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.

timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.

timeout(long, TimeUnit, CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time.

timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.

timeout(long, TimeUnit, Scheduler, CompletableSource) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.

timeout(Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a TimeoutException if an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.

timeout(Function>, Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, but that switches to a fallback Publisher if an item emitted by the current Flowable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by a Publisher that is a function of the previous item.

timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item.

timeout(long, TimeUnit, Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item.

timeout(long, TimeUnit, Scheduler, Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item using a specified Scheduler.

timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item, where this policy is governed by a specified Scheduler.

timeout(Publisher, Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, but notifies Subscribers of a TimeoutException if either the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows defined by other Publishers.

timeout(Publisher, Function>, Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that mirrors the current Flowable, but switches to a fallback Publisher if either the first item emitted by the current Flowable or any subsequent item doesn't arrive within time windows defined by other Publishers.

timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item.

timeout(long, TimeUnit, MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item.

timeout(long, TimeUnit, Scheduler, MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item using a specified Scheduler.

timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.

timeout(MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, a TimeoutException is signaled instead.

timeout(MaybeSource, MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

If the current Maybe didn't signal an event before the timeoutIndicator MaybeSource signals, the current Maybe is disposed and the fallback MaybeSource subscribed to as a continuation.

timeout(Publisher) - Method in class io.reactivex.rxjava3.core.Maybe

If the current Maybe source didn't signal an event before the timeoutIndicator Publisher signals, a TimeoutException is signaled instead.

timeout(Publisher, MaybeSource) - Method in class io.reactivex.rxjava3.core.Maybe

If the current Maybe didn't signal an event before the timeoutIndicator Publisher signals, the current Maybe is disposed and the fallback MaybeSource subscribed to as a continuation.

timeout(Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.

timeout(Function>, ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, but that switches to a fallback ObservableSource if an item emitted by the current Observable doesn't arrive within a window of time after the emission of the previous item, where that period of time is measured by an ObservableSource that is a function of the previous item.

timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item.

timeout(long, TimeUnit, ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item.

timeout(long, TimeUnit, Scheduler, ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item using a specified Scheduler.

timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.

timeout(ObservableSource, Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, but notifies observers of a TimeoutException if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.

timeout(ObservableSource, Function>, ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that mirrors the current Observable, but switches to a fallback ObservableSource if either the first item emitted by the current Observable or any subsequent item doesn't arrive within time windows defined by indicator ObservableSources.

timeout(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Single

Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.

timeout(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.

timeout(long, TimeUnit, Scheduler, SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.

timeout(long, TimeUnit, SingleSource) - Method in class io.reactivex.rxjava3.core.Single

Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.

timeout - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

Indicates that one of the awaitX method has timed out.

timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that fires its onComplete event after the given delay elapsed.

timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied Scheduler.

timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits 0L after a specified delay, and then completes.

timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes.

timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits 0L after a specified delay.

timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.

timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits 0L after a specified delay, and then completes.

timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.

timer(long, TimeUnit) - Static method in class io.reactivex.rxjava3.core.Single

Signals success with 0L value after the given delay when a SingleObserver subscribes.

timer(long, TimeUnit, Scheduler) - Static method in class io.reactivex.rxjava3.core.Single

Signals success with 0L value on the specified Scheduler after the given delay when a SingleObserver subscribes.

timestamp() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object.

timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.

timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object.

timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.

timestamp() - Method in class io.reactivex.rxjava3.core.Maybe

Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.

timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.

timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Maybe

Combines the success value from the current Maybe with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.

timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Combines the success value from the current Maybe with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.

timestamp() - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.

timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.

timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object.

timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.

timestamp() - Method in class io.reactivex.rxjava3.core.Single

Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the computation Scheduler as time source, then signals them as a Timed instance.

timestamp(Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.

timestamp(TimeUnit) - Method in class io.reactivex.rxjava3.core.Single

Combines the success value from the current Single with the current time of its reception, using the computation Scheduler as time source, then signals it as a Timed instance.

timestamp(TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Combines the success value from the current Single with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.

to(CompletableConverter) - Method in class io.reactivex.rxjava3.core.Completable

Calls the specified CompletableConverter function during assembly time and returns its resulting value.

to(FlowableConverter) - Method in class io.reactivex.rxjava3.core.Flowable

Calls the specified converter function during assembly time and returns its resulting value.

to(MaybeConverter) - Method in class io.reactivex.rxjava3.core.Maybe

Calls the specified converter function during assembly time and returns its resulting value.

to(ObservableConverter) - Method in class io.reactivex.rxjava3.core.Observable

Calls the specified converter function during assembly time and returns its resulting value.

to(SingleConverter) - Method in class io.reactivex.rxjava3.core.Single

Calls the specified converter function during assembly time and returns its resulting value.

to(ParallelFlowableConverter) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Calls the specified converter function during assembly time and returns its resulting value.

toAutoCloseable(Disposable) - Static method in interface io.reactivex.rxjava3.disposables.Disposable

Construct an AutoCloseable by wrapping a Disposable that is disposed when the returned AutoCloseable is closed.

toCompletionStage(T) - Method in class io.reactivex.rxjava3.core.Completable

Signals the given default item when the upstream completes or signals the upstream error via a CompletionStage.

toCompletionStage() - Method in class io.reactivex.rxjava3.core.Maybe

Signals the upstream success item (or a NoSuchElementException if the upstream is empty) via a CompletionStage.

toCompletionStage(T) - Method in class io.reactivex.rxjava3.core.Maybe

Signals the upstream success item (or the default item if the upstream is empty) via a CompletionStage.

toCompletionStage() - Method in class io.reactivex.rxjava3.core.Single

Signals the upstream success item (or error) via a CompletionStage.

toFlowable() - Method in class io.reactivex.rxjava3.core.Completable

Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the downstream Subscriber.

toFlowable() - Method in class io.reactivex.rxjava3.core.Maybe

Converts this Maybe into a backpressure-aware Flowable instance composing cancellation through.

toFlowable(BackpressureStrategy) - Method in class io.reactivex.rxjava3.core.Observable

Converts the current Observable into a Flowable by applying the specified backpressure strategy.

toFlowable() - Method in class io.reactivex.rxjava3.core.Single

Converts this Single into a Flowable.

toFuture() - Method in class io.reactivex.rxjava3.core.Completable

Returns a Future representing the termination of the current Completable via a null value.

toFuture() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Future representing the only value emitted by this Flowable.

toFuture() - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Future representing the single value emitted by the current Maybe or null if the current Maybe is empty.

toFuture() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Future representing the only value emitted by the current Observable.

toFuture() - Method in class io.reactivex.rxjava3.core.Single

Returns a Future representing the single value emitted by this Single.

toList() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single item, a list composed of all the items emitted by the finite upstream source Publisher.

toList(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.

toList(Supplier) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single item, a list composed of all the items emitted by the finite source Publisher.

toList() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single item, a List composed of all the items emitted by the current and finite Observable.

toList(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single item, a List composed of all the items emitted by the current and finite Observable.

toList(Supplier) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single item, a Collection (subclass) composed of all the items emitted by the finite upstream Observable.

toMap(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single HashMap containing all items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.

toMap(Function, Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single HashMap containing values corresponding to items emitted by the finite source Publisher, mapped by the keys returned by a specified keySelector function.

toMap(Function, Function, Supplier>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains keys and values extracted from the items emitted by the finite source Publisher.

toMap(Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single HashMap containing all items emitted by the current and finite Observable, mapped by the keys returned by a specified keySelector function.

toMap(Function, Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single HashMap containing values corresponding to items emitted by the current and finite Observable, mapped by the keys and values returned by the given selector functions.

toMap(Function, Function, Supplier>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains keys and values extracted from the items, via selector functions, emitted by the current and finite Observable.

toMaybe() - Method in class io.reactivex.rxjava3.core.Completable

Converts this Completable into a Maybe.

toMaybe() - Method in class io.reactivex.rxjava3.core.Single

Converts this Single into a Maybe.

toMultimap(Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the finite source Publisher keyed by a specified keySelector function.

toMultimap(Function, Function) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the finite source Publisher, keyed by a specified keySelector function.

toMultimap(Function, Function, Supplier>>, Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains a custom collection of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher, and keyed by the keySelector function.

toMultimap(Function, Function, Supplier>>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a single Map, returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the finite source Publisher and keyed by the keySelector function.

toMultimap(Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single HashMap that contains an ArrayList of items emitted by the current and finite Observable keyed by a specified keySelector function.

toMultimap(Function, Function) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single HashMap that contains an ArrayList of values extracted by a specified valueSelector function from items emitted by the current and finite Observable, keyed by a specified keySelector function.

toMultimap(Function, Function, Supplier>>, Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains a custom Collection of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable, and keyed by the keySelector function.

toMultimap(Function, Function, Supplier>>) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a single Map (subclass), returned by a specified mapFactory function, that contains an ArrayList of values, extracted by a specified valueSelector function from items emitted by the current and finite Observable and keyed by the keySelector function.

toObservable() - Method in class io.reactivex.rxjava3.core.Completable

Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the downstream Observer.

toObservable() - Method in class io.reactivex.rxjava3.core.Flowable

Converts the current Flowable into a non-backpressured Observable.

toObservable() - Method in class io.reactivex.rxjava3.core.Maybe

Converts this Maybe into an Observable instance composing disposal through.

toObservable() - Method in class io.reactivex.rxjava3.core.Single

Converts this Single into an Observable.

toSerialized() - Method in class io.reactivex.rxjava3.processors.FlowableProcessor

Wraps this FlowableProcessor and serializes the calls to the onSubscribe, onNext, onError and onComplete methods, making them thread-safe.

toSerialized() - Method in class io.reactivex.rxjava3.subjects.Subject

Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and onComplete methods, making them thread-safe.

toSingle(Supplier) - Method in class io.reactivex.rxjava3.core.Completable

Converts this Completable into a Single which when this Completable completes normally, calls the given Supplier and emits its returned value through onSuccess.

toSingle() - Method in class io.reactivex.rxjava3.core.Maybe

Converts this Maybe into a Single instance composing disposal through and turning an empty Maybe into a signal of NoSuchElementException.

toSingleDefault(T) - Method in class io.reactivex.rxjava3.core.Completable

Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.

toSortedList() - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order.

toSortedList(Comparator) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.

toSortedList(Comparator, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order based on a specified comparison function.

toSortedList(int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Single that emits a List that contains the items emitted by the finite source Publisher, in a sorted order.

toSortedList() - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order.

toSortedList(Comparator) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order based on a specified comparison function.

toSortedList(Comparator, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order based on a specified comparison function.

toSortedList(int) - Method in class io.reactivex.rxjava3.core.Observable

Returns a Single that emits a List that contains the items emitted by the current and finite Observable, in a sorted order.

toSortedList(Comparator) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.

toSortedList(Comparator, int) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.

toString() - Method in class io.reactivex.rxjava3.core.Notification

toString() - Method in class io.reactivex.rxjava3.schedulers.Timed

TRAMPOLINE - Static variable in annotation type io.reactivex.rxjava3.annotations.SchedulerSupport

The operator/class runs on RxJava's trampoline scheduler or takes timing information from it.

trampoline() - Static method in class io.reactivex.rxjava3.schedulers.Schedulers

Returns a default, shared Scheduler instance whose Scheduler.Worker instances queue work and execute them in a FIFO manner on one of the participating threads.

triggerActions() - Method in class io.reactivex.rxjava3.schedulers.TestScheduler

Triggers any actions that have not yet been triggered and that are scheduled to be triggered at or before this Scheduler's present time.

tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.CompletableEmitter

Attempts to emit the specified Throwable error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.

tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.FlowableEmitter

Attempts to emit the specified Throwable error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.

tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.MaybeEmitter

Attempts to emit the specified Throwable error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.

tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.ObservableEmitter

Attempts to emit the specified Throwable error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.

tryOnError(Throwable) - Method in interface io.reactivex.rxjava3.core.SingleEmitter

Attempts to emit the specified Throwable error if the downstream hasn't cancelled the sequence or is otherwise terminated, returning false if the emission is not allowed to happen due to lifecycle restrictions.

tryOnNext(T) - Method in interface io.reactivex.rxjava3.operators.ConditionalSubscriber

Conditionally takes the value.

U

UndeliverableException - Exception in io.reactivex.rxjava3.exceptions

Wrapper for Throwable errors that are sent to RxJavaPlugins.onError.

UndeliverableException(Throwable) - Constructor for exception io.reactivex.rxjava3.exceptions.UndeliverableException

Construct an instance by wrapping the given, non-null cause Throwable.

UnicastProcessor<T> - Class in io.reactivex.rxjava3.processors

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.

UnicastSubject<T> - Class in io.reactivex.rxjava3.subjects

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.

unit() - Method in class io.reactivex.rxjava3.schedulers.Timed

Returns the time unit of the contained time.

unsafeCreate(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Completable

Constructs a Completable instance by wrapping the given source callback without any safeguards; you should manage the lifecycle and response to downstream disposal.

unsafeCreate(Publisher) - Static method in class io.reactivex.rxjava3.core.Flowable

Create a Flowable by wrapping a Publisher which has to be implemented according to the Reactive Streams specification by handling backpressure and cancellation correctly; no safeguards are provided by the Flowable itself.

unsafeCreate(MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Advanced use only: creates a Maybe instance without any safeguards by using a callback that is called with a MaybeObserver.

unsafeCreate(ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Create an Observable by wrapping an ObservableSource which has to be implemented according to the Observable specification derived from the Reactive Streams specification by handling disposal correctly; no safeguards are provided by the Observable itself.

unsafeCreate(SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Advanced use only: creates a Single instance without any safeguards by using a callback that is called with a SingleObserver.

unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Completable

Returns a Completable which makes sure when an observer disposes the subscription, the dispose() method is called on the specified Scheduler.

unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Cancels the current Flowable asynchronously by invoking Subscription.cancel() on the specified Scheduler.

unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified Scheduler.

unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Return an Observable that schedules the downstream Observers' dispose calls aimed at the current Observable on the given Scheduler.

unsubscribeOn(Scheduler) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified Scheduler.

using(Supplier, Function, Consumer) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active.

using(Supplier, Function, Consumer, boolean) - Static method in class io.reactivex.rxjava3.core.Completable

Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active and performs eager or lazy resource disposition.

using(Supplier, Function>, Consumer) - Static method in class io.reactivex.rxjava3.core.Flowable

Constructs a Flowable that creates a dependent resource object, a Publisher with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream cancels the flow.

using(Supplier, Function>, Consumer, boolean) - Static method in class io.reactivex.rxjava3.core.Flowable

Constructs a Flowable that creates a dependent resource object, a Publisher with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.

using(Supplier, Function>, Consumer) - Static method in class io.reactivex.rxjava3.core.Maybe

Constructs a Maybe that creates a dependent resource object which is disposed of when the generated MaybeSource terminates or the downstream calls dispose().

using(Supplier, Function>, Consumer, boolean) - Static method in class io.reactivex.rxjava3.core.Maybe

Constructs a Maybe that creates a dependent resource object which is disposed first ({code eager == true}) when the generated MaybeSource terminates or the downstream disposes; or after ({code eager == false}).

using(Supplier, Function>, Consumer) - Static method in class io.reactivex.rxjava3.core.Observable

Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided resourceDisposer function if this inner source terminates or the downstream disposes the flow.

using(Supplier, Function>, Consumer, boolean) - Static method in class io.reactivex.rxjava3.core.Observable

Constructs an Observable that creates a dependent resource object, an ObservableSource with that resource and calls the provided disposer function if this inner source terminates or the downstream disposes the flow; doing it before these end-states have been reached if eager == true, after otherwise.

using(Supplier, Function>, Consumer) - Static method in class io.reactivex.rxjava3.core.Single

Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).

using(Supplier, Function>, Consumer, boolean) - Static method in class io.reactivex.rxjava3.core.Single

Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).

V

validate(Subscriber[]) - Method in class io.reactivex.rxjava3.parallel.ParallelFlowable

Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlowable.

value() - Method in class io.reactivex.rxjava3.schedulers.Timed

Returns the contained value.

valueAndClass(Object) - Static method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Appends the class name to a non-null value or returns "null".

valueOf(String) - Static method in enum io.reactivex.rxjava3.annotations.BackpressureKind

Returns the enum constant of this type with the specified name.

valueOf(String) - Static method in enum io.reactivex.rxjava3.core.BackpressureOverflowStrategy

Returns the enum constant of this type with the specified name.

valueOf(String) - Static method in enum io.reactivex.rxjava3.core.BackpressureStrategy

Returns the enum constant of this type with the specified name.

valueOf(String) - Static method in enum io.reactivex.rxjava3.parallel.ParallelFailureHandling

Returns the enum constant of this type with the specified name.

values() - Static method in enum io.reactivex.rxjava3.annotations.BackpressureKind

Returns an array containing the constants of this enum type, in the order they are declared.

values() - Static method in enum io.reactivex.rxjava3.core.BackpressureOverflowStrategy

Returns an array containing the constants of this enum type, in the order they are declared.

values() - Static method in enum io.reactivex.rxjava3.core.BackpressureStrategy

Returns an array containing the constants of this enum type, in the order they are declared.

values - Variable in class io.reactivex.rxjava3.observers.BaseTestConsumer

The list of values received.

values() - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Returns a shared list of received onNext values or the single onSuccess value.

values() - Static method in enum io.reactivex.rxjava3.parallel.ParallelFailureHandling

Returns an array containing the constants of this enum type, in the order they are declared.

W

when(Function>, Completable>) - Method in class io.reactivex.rxjava3.core.Scheduler

Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.

window(long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, long, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit, long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit, long, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit, Scheduler, long) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit, Scheduler, long, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long, TimeUnit, Scheduler, long, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(Publisher) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.

window(Publisher, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits non-overlapping windows of items it collects from the current Flowable where the boundary of each window is determined by the items emitted from a specified boundary-governing Publisher.

window(Publisher, Function>) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(Publisher, Function>, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits windows of items it collects from the current Flowable.

window(long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, long, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, long, TimeUnit, Scheduler, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit, long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit, long, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit, Scheduler) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit, Scheduler, long) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit, Scheduler, long, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(long, TimeUnit, Scheduler, long, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(ObservableSource) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

window(ObservableSource, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits non-overlapping windows of items it collects from the current Observable where the boundary of each window is determined by the items emitted from a specified boundary-governing ObservableSource.

window(ObservableSource, Function>) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

window(ObservableSource, Function>, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits windows of items it collects from the current Observable.

withLatestFrom(Publisher, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Merges the specified Publisher into the current Flowable sequence by using the resultSelector function only when the current Flowable (this instance) emits an item.

withLatestFrom(Publisher, Publisher, Function3) - Method in class io.reactivex.rxjava3.core.Flowable

Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.

withLatestFrom(Publisher, Publisher, Publisher, Function4) - Method in class io.reactivex.rxjava3.core.Flowable

Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.

withLatestFrom(Publisher, Publisher, Publisher, Publisher, Function5) - Method in class io.reactivex.rxjava3.core.Flowable

Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.

withLatestFrom(Publisher[], Function) - Method in class io.reactivex.rxjava3.core.Flowable

Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.

withLatestFrom(Iterable>, Function) - Method in class io.reactivex.rxjava3.core.Flowable

Combines the value emission from the current Flowable with the latest emissions from the other Publishers via a function to produce the output item.

withLatestFrom(ObservableSource, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Merges the specified ObservableSource into the current Observable sequence by using the resultSelector function only when the current Observable emits an item.

withLatestFrom(ObservableSource, ObservableSource, Function3) - Method in class io.reactivex.rxjava3.core.Observable

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

withLatestFrom(ObservableSource, ObservableSource, ObservableSource, Function4) - Method in class io.reactivex.rxjava3.core.Observable

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

withLatestFrom(ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function5) - Method in class io.reactivex.rxjava3.core.Observable

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

withLatestFrom(ObservableSource[], Function) - Method in class io.reactivex.rxjava3.core.Observable

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

withLatestFrom(Iterable>, Function) - Method in class io.reactivex.rxjava3.core.Observable

Combines the value emission from the current Observable with the latest emissions from the other ObservableSources via a function to produce the output item.

withTag(CharSequence) - Method in class io.reactivex.rxjava3.observers.BaseTestConsumer

Set the tag displayed along with an assertion failure's other state information.

Worker() - Constructor for class io.reactivex.rxjava3.core.Scheduler.Worker

wrap(CompletableSource) - Static method in class io.reactivex.rxjava3.core.Completable

Wraps the given CompletableSource into a Completable if not already Completable.

wrap(MaybeSource) - Static method in class io.reactivex.rxjava3.core.Maybe

Wraps a MaybeSource instance into a new Maybe instance if not already a Maybe instance.

wrap(ObservableSource) - Static method in class io.reactivex.rxjava3.core.Observable

Wraps an ObservableSource into an Observable if not already an Observable.

wrap(SingleSource) - Static method in class io.reactivex.rxjava3.core.Single

Wraps a SingleSource instance into a new Single instance if not already a Single instance.

Z

zip(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.

zip(Iterable>, Function, boolean, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other Publishers.

zip(Publisher, Publisher, BiFunction) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.

zip(Publisher, Publisher, BiFunction, boolean) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.

zip(Publisher, Publisher, BiFunction, boolean, int) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other Publishers.

zip(Publisher, Publisher, Publisher, Function3) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other Publishers.

zip(Publisher, Publisher, Publisher, Publisher, Function4) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other Publishers.

zip(Publisher, Publisher, Publisher, Publisher, Publisher, Function5) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other Publishers.

zip(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function6) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other Publishers.

zip(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function7) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other Publishers.

zip(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function8) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other Publishers.

zip(Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Publisher, Function9) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other Publishers.

zip(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other MaybeSources.

zip(MaybeSource, MaybeSource, BiFunction) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, Function3) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, MaybeSource, Function4) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, Function5) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, Function6) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, Function7) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, Function8) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other MaybeSources.

zip(MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, MaybeSource, Function9) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other MaybeSources.

zip(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.

zip(Iterable>, Function, boolean, int) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an Iterable of other ObservableSources.

zip(ObservableSource, ObservableSource, BiFunction) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.

zip(ObservableSource, ObservableSource, BiFunction, boolean) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.

zip(ObservableSource, ObservableSource, BiFunction, boolean, int) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of two items emitted, in sequence, by two other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, Function3) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of three items emitted, in sequence, by three other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function4) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of four items emitted, in sequence, by four other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function5) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of five items emitted, in sequence, by five other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function6) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of six items emitted, in sequence, by six other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function7) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of seven items emitted, in sequence, by seven other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function8) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of eight items emitted, in sequence, by eight other ObservableSources.

zip(ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, ObservableSource, Function9) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of nine items emitted, in sequence, by nine other ObservableSources.

zip(Iterable>, Function) - Static method in class io.reactivex.rxjava3.core.Single

Waits until all SingleSource sources provided by the Iterable sequence signal a success value and calls a zipper function with an array of these values to return a result to be emitted to the downstream.

zip(SingleSource, SingleSource, BiFunction) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to two items emitted by two other SingleSources.

zip(SingleSource, SingleSource, SingleSource, Function3) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to three items emitted by three other SingleSources.

zip(SingleSource, SingleSource, SingleSource, SingleSource, Function4) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to four items emitted by four other SingleSources.

zip(SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, Function5) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to five items emitted by five other SingleSources.

zip(SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, Function6) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to six items emitted by six other SingleSources.

zip(SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, Function7) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to seven items emitted by seven other SingleSources.

zip(SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, Function8) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to eight items emitted by eight other SingleSources.

zip(SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, SingleSource, Function9) - Static method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the results of a specified combiner function applied to nine items emitted by nine other SingleSources.

zipArray(Function, boolean, int, Publisher...) - Static method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other Publishers.

zipArray(Function, MaybeSource...) - Static method in class io.reactivex.rxjava3.core.Maybe

Returns a Maybe that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other MaybeSources.

zipArray(Function, boolean, int, ObservableSource...) - Static method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits the results of a specified combiner function applied to combinations of items emitted, in sequence, by an array of other ObservableSources.

zipArray(Function, SingleSource...) - Static method in class io.reactivex.rxjava3.core.Single

Waits until all SingleSource sources provided via an array signal a success value and calls a zipper function with an array of these values to return a result to be emitted to downstream.

zipWith(Iterable, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and a specified Iterable sequence.

zipWith(Publisher, BiFunction) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and another specified Publisher.

zipWith(Publisher, BiFunction, boolean) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and another specified Publisher.

zipWith(Publisher, BiFunction, boolean, int) - Method in class io.reactivex.rxjava3.core.Flowable

Returns a Flowable that emits items that are the result of applying a specified function to pairs of values, one each from the current Flowable and another specified Publisher.

zipWith(MaybeSource, BiFunction) - Method in class io.reactivex.rxjava3.core.Maybe

Waits until this and the other MaybeSource signal a success value then applies the given BiFunction to those values and emits the BiFunction's resulting value to downstream.

zipWith(Iterable, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and a specified Iterable sequence.

zipWith(ObservableSource, BiFunction) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

zipWith(ObservableSource, BiFunction, boolean) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

zipWith(ObservableSource, BiFunction, boolean, int) - Method in class io.reactivex.rxjava3.core.Observable

Returns an Observable that emits items that are the result of applying a specified function to pairs of values, one each from the current Observable and another specified ObservableSource.

zipWith(SingleSource, BiFunction) - Method in class io.reactivex.rxjava3.core.Single

Returns a Single that emits the result of applying a specified function to the pair of items emitted by the current Single and another specified SingleSource.

A B C D E F G H I J L M N O P Q R S T U V W Z