Uses of Interface
io.reactivex.rxjava3.functions.Consumer

Packages that use Consumer

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.flowables	Classes supporting the Flowable base reactive class: ConnectableFlowable and GroupedFlowable.
io.reactivex.rxjava3.internal.functions
io.reactivex.rxjava3.internal.observers
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.parallel
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.subscribers
io.reactivex.rxjava3.internal.util
io.reactivex.rxjava3.observables	Classes supporting the Observable base reactive class: ConnectableObservable and GroupedObservable.
io.reactivex.rxjava3.parallel	Contains the base type ParallelFlowable, a sub-DSL for working with Flowable sequences in parallel.
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.

Uses of Consumer in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core with parameters of type Consumer

Modifier and Type	Method	Description
void	Flowable.blockingForEach(@NonNull Consumer<? super @NonNull T> onNext)	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.
void	Flowable.blockingForEach(@NonNull Consumer<? super @NonNull T> onNext, int bufferSize)	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.
void	Observable.blockingForEach(@NonNull Consumer<? super @NonNull T> onNext)	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.
void	Observable.blockingForEach(@NonNull Consumer<? super @NonNull T> onNext, int capacityHint)	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.
void	Completable.blockingSubscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Completable and calls the appropriate callback on the current thread when it terminates.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the source and calls the given callbacks on the current thread.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, int bufferSize)	Subscribes to the source and calls the given callbacks on the current thread.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the source and calls the given callbacks on the current thread.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, int bufferSize)	Subscribes to the source and calls the given callbacks on the current thread.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the source and calls the given callbacks on the current thread.
void	Flowable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, int bufferSize)	Subscribes to the source and calls the given callbacks on the current thread.
void	Maybe.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess)	Subscribes to the current Maybe and calls given onSuccess callback on the current thread when it completes normally.
void	Maybe.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.
void	Maybe.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Maybe and calls the appropriate callback on the current thread when it terminates.
void	Observable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the source and calls the given callbacks on the current thread.
void	Observable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the source and calls the given callbacks on the current thread.
void	Observable.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the source and calls the given callbacks on the current thread.
void	Single.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess)	Subscribes to the current Single and calls given onSuccess callback on the current thread when it completes normally.
void	Single.blockingSubscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Single and calls the appropriate callback on the current thread when it terminates.
@NonNull Flowable<T>	Flowable.debounce(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Observable<T>	Observable.debounce(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.doAfterNext(@NonNull Consumer<? super @NonNull T> onAfterNext)	Calls the specified consumer with the current item after this item has been emitted to the downstream.
@NonNull Observable<T>	Observable.doAfterNext(@NonNull Consumer<? super @NonNull T> onAfterNext)	Calls the specified Consumer with the current item after this item has been emitted to the downstream.
@NonNull Maybe<T>	Maybe.doAfterSuccess(@NonNull Consumer<? super @NonNull T> onAfterSuccess)	Calls the specified Consumer with the success item after this item has been emitted to the downstream.
@NonNull Single<T>	Single.doAfterSuccess(@NonNull Consumer<? super @NonNull T> onAfterSuccess)	Calls the specified consumer with the success item after this item has been emitted to the downstream.
private @NonNull Flowable<T>	Flowable.doOnEach(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)	Calls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream.
@NonNull Flowable<T>	Flowable.doOnEach(@NonNull Consumer<? super Notification<@NonNull T>> onNotification)	Invokes a Consumer with a Notification instances matching the signals emitted by the current Flowable before they are forwarded to the downstream.
@NonNull Observable<T>	Observable.doOnEach(@NonNull Consumer<? super Notification<@NonNull T>> onNotification)	Returns an Observable that invokes a Consumer with the appropriate Notification object when the current Observable signals an item or terminates.
private @NonNull Observable<T>	Observable.doOnEach(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull Action onAfterTerminate)	Calls the appropriate onXXX consumer (shared between all Observers) whenever a signal with the same type passes through, before forwarding them to the downstream.
@NonNull Completable	Completable.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Returns a Completable which calls the given onError Consumer if this Completable emits an error.
@NonNull Flowable<T>	Flowable.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Calls the given Consumer with the error Throwable if the current Flowable failed before forwarding it to the downstream.
@NonNull Maybe<T>	Maybe.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Calls the shared Consumer with the error sent via onError for each MaybeObserver that subscribes to the current Maybe.
@NonNull Observable<T>	Observable.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Calls the given Consumer with the error Throwable if the current Observable failed before forwarding it to the downstream.
@NonNull Single<T>	Single.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Calls the shared consumer with the error sent via onError for each SingleObserver that subscribes to the current Single.
@NonNull Completable	Completable.doOnEvent(@NonNull Consumer<? super java.lang.Throwable> onEvent)	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.
@NonNull Completable	Completable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all CompletableObservers) for the lifecycle events of the sequence (subscription, disposal).
private @NonNull Completable	Completable.doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)	Returns a Completable instance that calls the various callbacks upon the specific lifecycle events.
@NonNull Flowable<T>	Flowable.doOnLifecycle(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe, @NonNull LongConsumer onRequest, @NonNull Action onCancel)	Calls the appropriate onXXX method (shared between all Subscribers) for the lifecycle events of the sequence (subscription, cancellation, requesting).
@NonNull Maybe<T>	Maybe.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all MaybeObservers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Observable<T>	Observable.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all Observers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Single<T>	Single.doOnLifecycle(@NonNull Consumer<? super Disposable> onSubscribe, @NonNull Action onDispose)	Calls the appropriate onXXX method (shared between all SingleObservers) for the lifecycle events of the sequence (subscription, disposal).
@NonNull Flowable<T>	Flowable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext)	Calls the given Consumer with the value emitted by the current Flowable before forwarding it to the downstream.
@NonNull Observable<T>	Observable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext)	Calls the given Consumer with the value emitted by the current Observable before forwarding it to the downstream.
@NonNull Completable	Completable.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Returns a Completable instance that calls the given onSubscribe callback with the disposable that the downstream CompletableObservers receive upon subscription.
@NonNull Flowable<T>	Flowable.doOnSubscribe(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe)	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.
@NonNull Maybe<T>	Maybe.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Calls the shared Consumer with the Disposable sent through the onSubscribe for each MaybeObserver that subscribes to the current Maybe.
@NonNull Observable<T>	Observable.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Returns an Observable so that it invokes the given Consumer when the current Observable is subscribed from its Observers.
@NonNull Single<T>	Single.doOnSubscribe(@NonNull Consumer<? super Disposable> onSubscribe)	Calls the shared consumer with the Disposable sent through the onSubscribe for each SingleObserver that subscribes to the current Single.
@NonNull Maybe<T>	Maybe.doOnSuccess(@NonNull Consumer<? super @NonNull T> onSuccess)	Calls the shared Consumer with the success value sent via onSuccess for each MaybeObserver that subscribes to the current Maybe.
@NonNull Single<T>	Single.doOnSuccess(@NonNull Consumer<? super @NonNull T> onSuccess)	Calls the shared consumer with the success value sent via onSuccess for each SingleObserver that subscribes to the current Single.
@NonNull Disposable	Flowable.forEach(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the current Flowable and receives notifications for each element.
@NonNull Disposable	Observable.forEach(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the ObservableSource and calls a Consumer for each item of the current Observable on its emission thread.
@NonNull Disposable	Flowable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Flowable and receives notifications for each element and error events until the onNext Predicate returns false.
@NonNull Disposable	Flowable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Flowable and receives notifications for each element and the terminal events until the onNext Predicate returns false.
@NonNull Disposable	Observable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)	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.
@NonNull Disposable	Observable.forEachWhile(@NonNull Predicate<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	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.
static <@NonNull T> @NonNull Flowable<T>	Flowable.generate(@NonNull Consumer<@NonNull Emitter<@NonNull T>> generator)	Returns a cold, synchronous, stateless and backpressure-aware generator of values.
static <@NonNull T,@NonNull S> @NonNull Flowable<T>	Flowable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S,Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState)	Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <@NonNull T,@NonNull S> @NonNull Flowable<T>	Flowable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S,@NonNull Emitter<@NonNull T>,@NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState)	Returns a cold, synchronous, stateful and backpressure-aware generator of values.
static <@NonNull T> @NonNull Observable<T>	Observable.generate(@NonNull Consumer<Emitter<@NonNull T>> generator)	Returns a cold, synchronous and stateless generator of values.
static <@NonNull T,@NonNull S> @NonNull Observable<T>	Observable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiConsumer<@NonNull S,Emitter<@NonNull T>> generator, @NonNull Consumer<? super @NonNull S> disposeState)	Returns a cold, synchronous and stateful generator of values.
static <@NonNull T,@NonNull S> @NonNull Observable<T>	Observable.generate(@NonNull Supplier<@NonNull S> initialState, @NonNull BiFunction<@NonNull S,Emitter<@NonNull T>,@NonNull S> generator, @NonNull Consumer<? super @NonNull S> disposeState)	Returns a cold, synchronous and stateful generator of values.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(int capacity, boolean delayError, boolean unbounded, @NonNull Action onOverflow, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.onBackpressureBuffer(long capacity, @Nullable Action onOverflow, @NonNull BackpressureOverflowStrategy overflowStrategy, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.onBackpressureDrop(@NonNull Consumer<? super @NonNull T> onDrop)	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.
@NonNull Flowable<T>	Flowable.onBackpressureLatest(@NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.sample(long period, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Observable<T>	Observable.sample(long period, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to this Completable and calls back either the onError or onComplete functions.
@NonNull Disposable	Completable.subscribe(@NonNull Action onComplete, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)	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.
@NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the current Flowable and provides a callback to handle the items it emits.
@NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error notification it issues.
@NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Flowable and provides callbacks to handle the items it emits and any error or completion notification it issues.
@NonNull Disposable	Flowable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	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.
@NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)	Subscribes to a Maybe and provides a callback to handle the items it emits.
@NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to a Maybe and provides callbacks to handle the items it emits and any error notification it issues.
@NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to a Maybe and provides callbacks to handle the items it emits and any error or completion notification it issues.
@NonNull Disposable	Maybe.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	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.
@NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext)	Subscribes to the current Observable and provides a callback to handle the items it emits.
@NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to the current Observable and provides callbacks to handle the items it emits and any error notification it signals.
@NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete)	Subscribes to the current Observable and provides callbacks to handle the items it emits and any error or completion notification it signals.
@NonNull Disposable	Observable.subscribe(@NonNull Consumer<? super @NonNull T> onNext, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull Action onComplete, @NonNull DisposableContainer container)	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.
@NonNull Disposable	Single.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess)	Subscribes to a Single and provides a callback to handle the item it emits.
@NonNull Disposable	Single.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError)	Subscribes to a Single and provides callbacks to handle the item it emits or any error notification it issues.
@NonNull Disposable	Single.subscribe(@NonNull Consumer<? super @NonNull T> onSuccess, @NonNull Consumer<? super java.lang.Throwable> onError, @NonNull DisposableContainer container)	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.
@NonNull Flowable<T>	Flowable.throttleFirst(long skipDuration, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Observable<T>	Observable.throttleFirst(long skipDuration, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.throttleLast(long intervalDuration, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Observable<T>	Observable.throttleLast(long intervalDuration, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Observable<T>	Observable.throttleLatest(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Flowable<T>	Flowable.throttleWithTimeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
@NonNull Observable<T>	Observable.throttleWithTimeout(long timeout, @NonNull java.util.concurrent.TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	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.
static <@NonNull R> @NonNull Completable	Completable.using(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R,? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup)	Returns a Completable instance which manages a resource along with a custom CompletableSource instance while the subscription is active.
static <@NonNull R> @NonNull Completable	Completable.using(@NonNull Supplier<@NonNull R> resourceSupplier, @NonNull Function<? super @NonNull R,? extends CompletableSource> sourceSupplier, @NonNull Consumer<? super @NonNull R> resourceCleanup, boolean eager)	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.
static <@NonNull T,@NonNull D> @NonNull Flowable<T>	Flowable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	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.
static <@NonNull T,@NonNull D> @NonNull Flowable<T>	Flowable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends org.reactivestreams.Publisher<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	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.
static <@NonNull T,@NonNull D> @NonNull Maybe<T>	Maybe.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	Constructs a Maybe that creates a dependent resource object which is disposed of when the generated MaybeSource terminates or the downstream calls dispose().
static <@NonNull T,@NonNull D> @NonNull Maybe<T>	Maybe.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends MaybeSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	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}).
static <@NonNull T,@NonNull D> @NonNull Observable<T>	Observable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup)	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.
static <@NonNull T,@NonNull D> @NonNull Observable<T>	Observable.using(@NonNull Supplier<? extends @NonNull D> resourceSupplier, @NonNull Function<? super @NonNull D,? extends ObservableSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull D> resourceCleanup, boolean eager)	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.
static <@NonNull T,@NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U,? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).
static <@NonNull T,@NonNull U> @NonNull Single<T>	Single.using(@NonNull Supplier<@NonNull U> resourceSupplier, @NonNull Function<? super @NonNull U,? extends SingleSource<? extends @NonNull T>> sourceSupplier, @NonNull Consumer<? super @NonNull U> resourceCleanup, boolean eager)	Allows using and disposing a resource while running a SingleSource instance generated from that resource (similar to a try-with-resources).

Uses of Consumer in io.reactivex.rxjava3.flowables

Methods in io.reactivex.rxjava3.flowables with parameters of type Consumer

Modifier and Type	Method	Description
@NonNull Flowable<T>	ConnectableFlowable.autoConnect(int numberOfSubscribers, @NonNull Consumer<? super Disposable> connection)	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.
abstract void	ConnectableFlowable.connect(@NonNull Consumer<? super Disposable> connection)	Instructs the ConnectableFlowable to begin emitting the items from its underlying Flowable to its Subscribers.

Uses of Consumer in io.reactivex.rxjava3.internal.functions

Classes in io.reactivex.rxjava3.internal.functions that implement Consumer

Modifier and Type	Class	Description
(package private) static class	Functions.ActionConsumer<T>
static class	Functions.BoundedConsumer
(package private) static class	Functions.EmptyConsumer
(package private) static class	Functions.ErrorConsumer
(package private) static class	Functions.MaxRequestSubscription
(package private) static class	Functions.NotificationOnError<T>
(package private) static class	Functions.NotificationOnNext<T>
(package private) static class	Functions.OnErrorMissingConsumer

Fields in io.reactivex.rxjava3.internal.functions declared as Consumer

Modifier and Type	Field	Description
(package private) static Consumer<java.lang.Object>	Functions.EMPTY_CONSUMER
static Consumer<java.lang.Throwable>	Functions.ERROR_CONSUMER
static Consumer<java.lang.Throwable>	Functions.ON_ERROR_MISSING	Wraps the consumed Throwable into an OnErrorNotImplementedException and signals it to the plugin error handler.
(package private) Consumer<? super Notification<T>>	Functions.NotificationOnComplete.onNotification
(package private) Consumer<? super Notification<T>>	Functions.NotificationOnError.onNotification
(package private) Consumer<? super Notification<T>>	Functions.NotificationOnNext.onNotification
static Consumer<org.reactivestreams.Subscription>	Functions.REQUEST_MAX

Methods in io.reactivex.rxjava3.internal.functions that return Consumer

Modifier and Type	Method	Description
static <T> Consumer<T>	Functions.actionConsumer(Action action)
static <T> Consumer<T>	Functions.boundedConsumer(int bufferSize)
static <T> Consumer<T>	Functions.emptyConsumer()	Returns an empty consumer that does nothing.
static <T> Consumer<java.lang.Throwable>	Functions.notificationOnError(Consumer<? super Notification<T>> onNotification)
static <T> Consumer<T>	Functions.notificationOnNext(Consumer<? super Notification<T>> onNotification)

Methods in io.reactivex.rxjava3.internal.functions with parameters of type Consumer

Modifier and Type	Method	Description
static <T> Action	Functions.notificationOnComplete(Consumer<? super Notification<T>> onNotification)
static <T> Consumer<java.lang.Throwable>	Functions.notificationOnError(Consumer<? super Notification<T>> onNotification)
static <T> Consumer<T>	Functions.notificationOnNext(Consumer<? super Notification<T>> onNotification)

Constructors in io.reactivex.rxjava3.internal.functions with parameters of type Consumer

Constructor	Description
NotificationOnComplete(Consumer<? super Notification<T>> onNotification)
NotificationOnError(Consumer<? super Notification<T>> onNotification)
NotificationOnNext(Consumer<? super Notification<T>> onNotification)

Uses of Consumer in io.reactivex.rxjava3.internal.observers

Fields in io.reactivex.rxjava3.internal.observers declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super java.lang.Throwable>	AbstractDisposableAutoRelease.onError
(package private) Consumer<? super java.lang.Throwable>	CallbackCompletableObserver.onError
(package private) Consumer<? super java.lang.Throwable>	ConsumerSingleObserver.onError
(package private) Consumer<? super java.lang.Throwable>	ForEachWhileObserver.onError
(package private) Consumer<? super java.lang.Throwable>	LambdaObserver.onError
(package private) Consumer<? super T>	DisposableAutoReleaseObserver.onNext
(package private) Consumer<? super T>	LambdaObserver.onNext
(package private) Consumer<? super Disposable>	DisposableLambdaObserver.onSubscribe
(package private) Consumer<? super Disposable>	LambdaObserver.onSubscribe
(package private) Consumer<? super T>	ConsumerSingleObserver.onSuccess
(package private) Consumer<? super T>	DisposableAutoReleaseMultiObserver.onSuccess

Methods in io.reactivex.rxjava3.internal.observers with parameters of type Consumer

Modifier and Type	Method	Description
void	BlockingMultiObserver.blockingConsume(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Blocks until the source completes and calls the appropriate callback.

Constructors in io.reactivex.rxjava3.internal.observers with parameters of type Consumer

Constructor	Description
AbstractDisposableAutoRelease(DisposableContainer composite, Consumer<? super java.lang.Throwable> onError, Action onComplete)
CallbackCompletableObserver(Consumer<? super java.lang.Throwable> onError, Action onComplete)
ConsumerSingleObserver(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError)
DisposableAutoReleaseMultiObserver(DisposableContainer composite, Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)
DisposableAutoReleaseObserver(DisposableContainer composite, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
DisposableLambdaObserver(Observer<? super T> actual, Consumer<? super Disposable> onSubscribe, Action onDispose)
ForEachWhileObserver(Predicate<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
LambdaObserver(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe)

Uses of Consumer in io.reactivex.rxjava3.internal.operators.completable

Fields in io.reactivex.rxjava3.internal.operators.completable declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super R>	CompletableUsing.disposer
(package private) Consumer<? super R>	CompletableUsing.UsingObserver.disposer
(package private) Consumer<? super java.lang.Throwable>	CompletablePeek.onError
(package private) Consumer<? super java.lang.Throwable>	CompletableDoOnEvent.onEvent
(package private) Consumer<? super Disposable>	CompletablePeek.onSubscribe

Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type Consumer

Constructor	Description
CompletableDoOnEvent(CompletableSource source, Consumer<? super java.lang.Throwable> onEvent)
CompletablePeek(CompletableSource source, Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onTerminate, Action onAfterTerminate, Action onDispose)
CompletableUsing(Supplier<R> resourceSupplier, Function<? super R,? extends CompletableSource> completableFunction, Consumer<? super R> disposer, boolean eager)
UsingObserver(CompletableObserver actual, R resource, Consumer<? super R> disposer, boolean eager)

Uses of Consumer in io.reactivex.rxjava3.internal.operators.flowable

Classes in io.reactivex.rxjava3.internal.operators.flowable that implement Consumer

Modifier and Type	Class	Description
(package private) static class	FlowableGroupBy.EvictionAction<K,V>
static class	FlowableInternalHelper.RequestMax
(package private) static class	FlowableInternalHelper.SubscriberOnError<T>
(package private) static class	FlowableInternalHelper.SubscriberOnNext<T>
class	FlowableOnBackpressureDrop<T>
(package private) static class	FlowableRefCount.RefConnection
(package private) class	FlowableReplay.MulticastFlowable.DisposableConsumer

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super Disposable>	FlowableAutoConnect.connection
(package private) Consumer<Emitter<T>>	FlowableInternalHelper.SimpleGenerator.consumer
(package private) Consumer<? super D>	FlowableUsing.disposer
(package private) Consumer<? super D>	FlowableUsing.UsingSubscriber.disposer
(package private) Consumer<? super S>	FlowableGenerate.disposeState
(package private) Consumer<? super S>	FlowableGenerate.GeneratorSubscription.disposeState
(package private) Consumer<? super T>	FlowableDoAfterNext.DoAfterConditionalSubscriber.onAfterNext
(package private) Consumer<? super T>	FlowableDoAfterNext.DoAfterSubscriber.onAfterNext
(package private) Consumer<? super T>	FlowableDoAfterNext.onAfterNext
(package private) Consumer<? super T>	FlowableOnBackpressureDrop.BackpressureDropSubscriber.onDrop
(package private) Consumer<? super T>	FlowableOnBackpressureDrop.onDrop
(package private) Consumer<? super T>	FlowableDebounceTimed.DebounceTimedSubscriber.onDropped
(package private) Consumer<? super T>	FlowableDebounceTimed.onDropped
(package private) Consumer<? super T>	FlowableOnBackpressureBuffer.BackpressureBufferSubscriber.onDropped
(package private) Consumer<? super T>	FlowableOnBackpressureBuffer.onDropped
(package private) Consumer<? super T>	FlowableOnBackpressureBufferStrategy.OnBackpressureBufferStrategySubscriber.onDropped
(package private) Consumer<? super T>	FlowableOnBackpressureBufferStrategy.onDropped
(package private) Consumer<? super T>	FlowableOnBackpressureLatest.BackpressureLatestSubscriber.onDropped
(package private) Consumer<? super T>	FlowableOnBackpressureLatest.onDropped
(package private) Consumer<? super T>	FlowableSampleTimed.onDropped
(package private) Consumer<? super T>	FlowableSampleTimed.SampleTimedSubscriber.onDropped
(package private) Consumer<? super T>	FlowableThrottleFirstTimed.DebounceTimedSubscriber.onDropped
(package private) Consumer<? super T>	FlowableThrottleFirstTimed.onDropped
(package private) Consumer<? super T>	FlowableThrottleLatest.onDropped
(package private) Consumer<? super T>	FlowableThrottleLatest.ThrottleLatestSubscriber.onDropped
(package private) Consumer<? super java.lang.Throwable>	FlowableDoOnEach.DoOnEachConditionalSubscriber.onError
(package private) Consumer<? super java.lang.Throwable>	FlowableDoOnEach.DoOnEachSubscriber.onError
(package private) Consumer<? super java.lang.Throwable>	FlowableDoOnEach.onError
(package private) Consumer<? super T>	FlowableDoOnEach.DoOnEachConditionalSubscriber.onNext
(package private) Consumer<? super T>	FlowableDoOnEach.DoOnEachSubscriber.onNext
(package private) Consumer<? super T>	FlowableDoOnEach.onNext
private Consumer<? super org.reactivestreams.Subscription>	FlowableDoOnLifecycle.onSubscribe
(package private) Consumer<? super org.reactivestreams.Subscription>	FlowableDoOnLifecycle.SubscriptionLambdaSubscriber.onSubscribe

Fields in io.reactivex.rxjava3.internal.operators.flowable with type parameters of type Consumer

Modifier and Type	Field	Description
(package private) Function<? super Consumer<java.lang.Object>,? extends java.util.Map<K,java.lang.Object>>	FlowableGroupBy.mapFactory

Methods in io.reactivex.rxjava3.internal.operators.flowable that return Consumer

Modifier and Type	Method	Description
static <T> Consumer<java.lang.Throwable>	FlowableInternalHelper.subscriberOnError(org.reactivestreams.Subscriber<T> subscriber)
static <T> Consumer<T>	FlowableInternalHelper.subscriberOnNext(org.reactivestreams.Subscriber<T> subscriber)

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Consumer

Modifier and Type	Method	Description
void	FlowablePublish.connect(Consumer<? super Disposable> connection)
void	FlowableReplay.connect(Consumer<? super Disposable> connection)
static <T,S> BiFunction<S,Emitter<T>,S>	FlowableInternalHelper.simpleGenerator(Consumer<Emitter<T>> consumer)
static <T> void	FlowableBlockingSubscribe.subscribe(org.reactivestreams.Publisher<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Subscribes to the source and calls the given actions on the current thread.
static <T> void	FlowableBlockingSubscribe.subscribe(org.reactivestreams.Publisher<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, int bufferSize)	Subscribes to the source and calls the given actions on the current thread.

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Consumer

Constructor	Description
BackpressureBufferSubscriber(org.reactivestreams.Subscriber<? super T> actual, int bufferSize, boolean unbounded, boolean delayError, Action onOverflow, Consumer<? super T> onDropped)
BackpressureDropSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super T> onDrop)
BackpressureLatestSubscriber(org.reactivestreams.Subscriber<? super T> downstream, Consumer<? super T> onDropped)
DebounceTimedSubscriber(org.reactivestreams.Subscriber<? super T> actual, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, Consumer<? super T> onDropped)
DebounceTimedSubscriber(org.reactivestreams.Subscriber<? super T> actual, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, Consumer<? super T> onDropped)
DoAfterConditionalSubscriber(ConditionalSubscriber<? super T> actual, Consumer<? super T> onAfterNext)
DoAfterSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super T> onAfterNext)
DoOnEachConditionalSubscriber(ConditionalSubscriber<? super T> actual, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
DoOnEachSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
FlowableAutoConnect(ConnectableFlowable<? extends T> source, int numberOfSubscribers, Consumer<? super Disposable> connection)
FlowableDebounceTimed(Flowable<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
FlowableDoAfterNext(Flowable<T> source, Consumer<? super T> onAfterNext)
FlowableDoOnEach(Flowable<T> source, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
FlowableDoOnLifecycle(Flowable<T> source, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)
FlowableGenerate(Supplier<S> stateSupplier, BiFunction<S,Emitter<T>,S> generator, Consumer<? super S> disposeState)
FlowableOnBackpressureBuffer(Flowable<T> source, int bufferSize, boolean unbounded, boolean delayError, Action onOverflow, Consumer<? super T> onDropped)
FlowableOnBackpressureBufferStrategy(Flowable<T> source, long bufferSize, Action onOverflow, BackpressureOverflowStrategy strategy, Consumer<? super T> onDropped)
FlowableOnBackpressureDrop(Flowable<T> source, Consumer<? super T> onDrop)
FlowableOnBackpressureLatest(Flowable<T> source, Consumer<? super T> onDropped)
FlowableSampleTimed(Flowable<T> source, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
FlowableThrottleFirstTimed(Flowable<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
FlowableThrottleLatest(Flowable<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
FlowableUsing(Supplier<? extends D> resourceSupplier, Function<? super D,? extends org.reactivestreams.Publisher<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
GeneratorSubscription(org.reactivestreams.Subscriber<? super T> actual, BiFunction<S,? super Emitter<T>,S> generator, Consumer<? super S> disposeState, S initialState)
OnBackpressureBufferStrategySubscriber(org.reactivestreams.Subscriber<? super T> actual, Action onOverflow, BackpressureOverflowStrategy strategy, long bufferSize, Consumer<? super T> onDropped)
SampleTimedEmitLast(org.reactivestreams.Subscriber<? super T> actual, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
SampleTimedNoLast(org.reactivestreams.Subscriber<? super T> actual, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
SampleTimedSubscriber(org.reactivestreams.Subscriber<? super T> actual, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
SimpleGenerator(Consumer<Emitter<T>> consumer)
SubscriptionLambdaSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)
ThrottleLatestSubscriber(org.reactivestreams.Subscriber<? super T> downstream, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, boolean emitLast, Consumer<? super T> onDropped)
UsingSubscriber(org.reactivestreams.Subscriber<? super T> actual, D resource, Consumer<? super D> disposer, boolean eager)

Uses of Consumer in io.reactivex.rxjava3.internal.operators.maybe

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super D>	MaybeUsing.UsingObserver.disposer
(package private) Consumer<? super T>	MaybeDoAfterSuccess.DoAfterObserver.onAfterSuccess
(package private) Consumer<? super T>	MaybeDoAfterSuccess.onAfterSuccess
(package private) Consumer<? super java.lang.Throwable>	MaybeCallbackObserver.onError
(package private) Consumer<? super java.lang.Throwable>	MaybePeek.onErrorCall
(package private) Consumer<? super Disposable>	MaybeDoOnLifecycle.MaybeLifecycleObserver.onSubscribe
(package private) Consumer<? super Disposable>	MaybeDoOnLifecycle.onSubscribe
(package private) Consumer<? super Disposable>	MaybePeek.onSubscribeCall
(package private) Consumer<? super T>	MaybeCallbackObserver.onSuccess
(package private) Consumer<? super T>	MaybePeek.onSuccessCall
(package private) Consumer<? super D>	MaybeUsing.resourceDisposer

Constructors in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Consumer

Constructor	Description
DoAfterObserver(MaybeObserver<? super T> actual, Consumer<? super T> onAfterSuccess)
MaybeCallbackObserver(Consumer<? super T> onSuccess, Consumer<? super java.lang.Throwable> onError, Action onComplete)
MaybeDoAfterSuccess(MaybeSource<T> source, Consumer<? super T> onAfterSuccess)
MaybeDoOnLifecycle(Maybe<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybeLifecycleObserver(MaybeObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
MaybePeek(MaybeSource<T> source, Consumer<? super Disposable> onSubscribeCall, Consumer<? super T> onSuccessCall, Consumer<? super java.lang.Throwable> onErrorCall, Action onCompleteCall, Action onAfterTerminate, Action onDispose)
MaybeUsing(Supplier<? extends D> resourceSupplier, Function<? super D,? extends MaybeSource<? extends T>> sourceSupplier, Consumer<? super D> resourceDisposer, boolean eager)
UsingObserver(MaybeObserver<? super T> actual, D resource, Consumer<? super D> disposer, boolean eager)

Uses of Consumer in io.reactivex.rxjava3.internal.operators.observable

Classes in io.reactivex.rxjava3.internal.operators.observable that implement Consumer

Modifier and Type	Class	Description
(package private) static class	ObservableInternalHelper.ObserverOnError<T>
(package private) static class	ObservableInternalHelper.ObserverOnNext<T>
(package private) static class	ObservableRefCount.RefConnection
(package private) static class	ObservableReplay.DisposeConsumer<R>

Fields in io.reactivex.rxjava3.internal.operators.observable declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super Disposable>	ObservableAutoConnect.connection
(package private) Consumer<Emitter<T>>	ObservableInternalHelper.SimpleGenerator.consumer
(package private) Consumer<? super D>	ObservableUsing.disposer
(package private) Consumer<? super D>	ObservableUsing.UsingObserver.disposer
(package private) Consumer<? super S>	ObservableGenerate.disposeState
(package private) Consumer<? super S>	ObservableGenerate.GeneratorDisposable.disposeState
(package private) Consumer<? super T>	ObservableDoAfterNext.DoAfterObserver.onAfterNext
(package private) Consumer<? super T>	ObservableDoAfterNext.onAfterNext
(package private) Consumer<? super T>	ObservableDebounceTimed.DebounceTimedObserver.onDropped
(package private) Consumer<? super T>	ObservableDebounceTimed.onDropped
(package private) Consumer<? super T>	ObservableSampleTimed.onDropped
(package private) Consumer<? super T>	ObservableSampleTimed.SampleTimedObserver.onDropped
(package private) Consumer<? super T>	ObservableThrottleFirstTimed.DebounceTimedObserver.onDropped
(package private) Consumer<? super T>	ObservableThrottleFirstTimed.onDropped
(package private) Consumer<? super T>	ObservableThrottleLatest.onDropped
(package private) Consumer<? super T>	ObservableThrottleLatest.ThrottleLatestObserver.onDropped
(package private) Consumer<? super java.lang.Throwable>	ObservableDoOnEach.DoOnEachObserver.onError
(package private) Consumer<? super java.lang.Throwable>	ObservableDoOnEach.onError
(package private) Consumer<? super T>	ObservableDoOnEach.DoOnEachObserver.onNext
(package private) Consumer<? super T>	ObservableDoOnEach.onNext
private Consumer<? super Disposable>	ObservableDoOnLifecycle.onSubscribe

Methods in io.reactivex.rxjava3.internal.operators.observable that return Consumer

Modifier and Type	Method	Description
static <T> Consumer<java.lang.Throwable>	ObservableInternalHelper.observerOnError(Observer<T> observer)
static <T> Consumer<T>	ObservableInternalHelper.observerOnNext(Observer<T> observer)

Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type Consumer

Modifier and Type	Method	Description
void	ObservablePublish.connect(Consumer<? super Disposable> connection)
void	ObservableReplay.connect(Consumer<? super Disposable> connection)
static <T,S> BiFunction<S,Emitter<T>,S>	ObservableInternalHelper.simpleGenerator(Consumer<Emitter<T>> consumer)
static <T> void	ObservableBlockingSubscribe.subscribe(ObservableSource<? extends T> o, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)	Subscribes to the source and calls the given actions on the current thread.

Constructors in io.reactivex.rxjava3.internal.operators.observable with parameters of type Consumer

Constructor	Description
DebounceTimedObserver(Observer<? super T> actual, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, Consumer<? super T> onDropped)
DebounceTimedObserver(Observer<? super T> actual, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, Consumer<? super T> onDropped)
DoAfterObserver(Observer<? super T> actual, Consumer<? super T> onAfterNext)
DoOnEachObserver(Observer<? super T> actual, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
GeneratorDisposable(Observer<? super T> actual, BiFunction<S,? super Emitter<T>,S> generator, Consumer<? super S> disposeState, S initialState)
ObservableAutoConnect(ConnectableObservable<? extends T> source, int numberOfObservers, Consumer<? super Disposable> connection)
ObservableDebounceTimed(ObservableSource<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
ObservableDoAfterNext(ObservableSource<T> source, Consumer<? super T> onAfterNext)
ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminate)
ObservableDoOnLifecycle(Observable<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
ObservableGenerate(Supplier<S> stateSupplier, BiFunction<S,Emitter<T>,S> generator, Consumer<? super S> disposeState)
ObservableSampleTimed(ObservableSource<T> source, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
ObservableThrottleFirstTimed(ObservableSource<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
ObservableThrottleLatest(Observable<T> source, long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
ObservableUsing(Supplier<? extends D> resourceSupplier, Function<? super D,? extends ObservableSource<? extends T>> sourceSupplier, Consumer<? super D> disposer, boolean eager)
SampleTimedEmitLast(Observer<? super T> actual, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
SampleTimedNoLast(Observer<? super T> actual, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
SampleTimedObserver(Observer<? super T> actual, long period, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
SimpleGenerator(Consumer<Emitter<T>> consumer)
ThrottleLatestObserver(Observer<? super T> downstream, long timeout, java.util.concurrent.TimeUnit unit, Scheduler.Worker worker, boolean emitLast, Consumer<? super T> onDropped)
UsingObserver(Observer<? super T> actual, D resource, Consumer<? super D> disposer, boolean eager)

Uses of Consumer in io.reactivex.rxjava3.internal.operators.parallel

Fields in io.reactivex.rxjava3.internal.operators.parallel declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super T>	ParallelPeek.onAfterNext
(package private) Consumer<? super java.lang.Throwable>	ParallelPeek.onError
(package private) Consumer<? super T>	ParallelDoOnNextTry.onNext
(package private) Consumer<? super T>	ParallelDoOnNextTry.ParallelDoOnNextConditionalSubscriber.onNext
(package private) Consumer<? super T>	ParallelDoOnNextTry.ParallelDoOnNextSubscriber.onNext
(package private) Consumer<? super T>	ParallelPeek.onNext
(package private) Consumer<? super org.reactivestreams.Subscription>	ParallelPeek.onSubscribe

Constructors in io.reactivex.rxjava3.internal.operators.parallel with parameters of type Consumer

Constructor	Description
ParallelDoOnNextConditionalSubscriber(ConditionalSubscriber<? super T> actual, Consumer<? super T> onNext, BiFunction<? super java.lang.Long,? super java.lang.Throwable,ParallelFailureHandling> errorHandler)
ParallelDoOnNextSubscriber(org.reactivestreams.Subscriber<? super T> actual, Consumer<? super T> onNext, BiFunction<? super java.lang.Long,? super java.lang.Throwable,ParallelFailureHandling> errorHandler)
ParallelDoOnNextTry(ParallelFlowable<T> source, Consumer<? super T> onNext, BiFunction<? super java.lang.Long,? super java.lang.Throwable,ParallelFailureHandling> errorHandler)
ParallelPeek(ParallelFlowable<T> source, Consumer<? super T> onNext, Consumer<? super T> onAfterNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Action onAfterTerminated, Consumer<? super org.reactivestreams.Subscription> onSubscribe, LongConsumer onRequest, Action onCancel)

Uses of Consumer in io.reactivex.rxjava3.internal.operators.single

Fields in io.reactivex.rxjava3.internal.operators.single declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super U>	SingleUsing.disposer
(package private) Consumer<? super U>	SingleUsing.UsingSingleObserver.disposer
(package private) Consumer<? super T>	SingleDoAfterSuccess.DoAfterObserver.onAfterSuccess
(package private) Consumer<? super T>	SingleDoAfterSuccess.onAfterSuccess
(package private) Consumer<? super java.lang.Throwable>	SingleDoOnError.onError
(package private) Consumer<? super Disposable>	SingleDoOnLifecycle.onSubscribe
(package private) Consumer<? super Disposable>	SingleDoOnLifecycle.SingleLifecycleObserver.onSubscribe
(package private) Consumer<? super Disposable>	SingleDoOnSubscribe.DoOnSubscribeSingleObserver.onSubscribe
(package private) Consumer<? super Disposable>	SingleDoOnSubscribe.onSubscribe
(package private) Consumer<? super T>	SingleDoOnSuccess.onSuccess

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type Consumer

Constructor	Description
DoAfterObserver(SingleObserver<? super T> actual, Consumer<? super T> onAfterSuccess)
DoOnSubscribeSingleObserver(SingleObserver<? super T> actual, Consumer<? super Disposable> onSubscribe)
SingleDoAfterSuccess(SingleSource<T> source, Consumer<? super T> onAfterSuccess)
SingleDoOnError(SingleSource<T> source, Consumer<? super java.lang.Throwable> onError)
SingleDoOnLifecycle(Single<T> upstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
SingleDoOnSubscribe(SingleSource<T> source, Consumer<? super Disposable> onSubscribe)
SingleDoOnSuccess(SingleSource<T> source, Consumer<? super T> onSuccess)
SingleLifecycleObserver(SingleObserver<? super T> downstream, Consumer<? super Disposable> onSubscribe, Action onDispose)
SingleUsing(Supplier<U> resourceSupplier, Function<? super U,? extends SingleSource<? extends T>> singleFunction, Consumer<? super U> disposer, boolean eager)
UsingSingleObserver(SingleObserver<? super T> actual, U resource, boolean eager, Consumer<? super U> disposer)

Uses of Consumer in io.reactivex.rxjava3.internal.subscribers

Fields in io.reactivex.rxjava3.internal.subscribers declared as Consumer

Modifier and Type	Field	Description
(package private) Consumer<? super java.lang.Throwable>	BoundedSubscriber.onError
(package private) Consumer<? super java.lang.Throwable>	DisposableAutoReleaseSubscriber.onError
(package private) Consumer<? super java.lang.Throwable>	ForEachWhileSubscriber.onError
(package private) Consumer<? super java.lang.Throwable>	LambdaSubscriber.onError
(package private) Consumer<? super T>	BoundedSubscriber.onNext
(package private) Consumer<? super T>	DisposableAutoReleaseSubscriber.onNext
(package private) Consumer<? super T>	LambdaSubscriber.onNext
(package private) Consumer<? super org.reactivestreams.Subscription>	BoundedSubscriber.onSubscribe
(package private) Consumer<? super org.reactivestreams.Subscription>	LambdaSubscriber.onSubscribe

Constructors in io.reactivex.rxjava3.internal.subscribers with parameters of type Consumer

Constructor	Description
BoundedSubscriber(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Consumer<? super org.reactivestreams.Subscription> onSubscribe, int bufferSize)
DisposableAutoReleaseSubscriber(DisposableContainer composite, Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
ForEachWhileSubscriber(Predicate<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete)
LambdaSubscriber(Consumer<? super T> onNext, Consumer<? super java.lang.Throwable> onError, Action onComplete, Consumer<? super org.reactivestreams.Subscription> onSubscribe)

Uses of Consumer in io.reactivex.rxjava3.internal.util

Classes in io.reactivex.rxjava3.internal.util that implement Consumer

Modifier and Type	Class	Description
class	BlockingIgnoringReceiver	Stores an incoming Throwable (if any) and counts itself down.
class	ConnectConsumer	Store the Disposable received from the connection.

Uses of Consumer in io.reactivex.rxjava3.observables

Methods in io.reactivex.rxjava3.observables with parameters of type Consumer

Modifier and Type	Method	Description
@NonNull Observable<T>	ConnectableObservable.autoConnect(int numberOfObservers, @NonNull Consumer<? super Disposable> connection)	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.
abstract void	ConnectableObservable.connect(@NonNull Consumer<? super Disposable> connection)	Instructs the ConnectableObservable to begin emitting the items from its underlying Observable to its Observers.

Uses of Consumer in io.reactivex.rxjava3.parallel

Methods in io.reactivex.rxjava3.parallel with parameters of type Consumer

Modifier and Type	Method	Description
@NonNull ParallelFlowable<T>	ParallelFlowable.doAfterNext(@NonNull Consumer<? super @NonNull T> onAfterNext)	Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnError(@NonNull Consumer<? super java.lang.Throwable> onError)	Call the specified consumer with the exception passing through any 'rail'.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext)	Call the specified consumer with the current element passing through any 'rail'.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext, @NonNull BiFunction<? super java.lang.Long,? super java.lang.Throwable,ParallelFailureHandling> errorHandler)	Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnNext(@NonNull Consumer<? super @NonNull T> onNext, @NonNull ParallelFailureHandling errorHandler)	Call the specified consumer with the current element passing through any 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.
@NonNull ParallelFlowable<T>	ParallelFlowable.doOnSubscribe(@NonNull Consumer<? super org.reactivestreams.Subscription> onSubscribe)	Call the specified callback when a 'rail' receives a Subscription from its upstream.

Uses of Consumer in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins declared as Consumer

Modifier and Type	Field	Description
(package private) static @Nullable Consumer<? super java.lang.Throwable>	RxJavaPlugins.errorHandler

Methods in io.reactivex.rxjava3.plugins that return Consumer

Modifier and Type	Method	Description
static @Nullable Consumer<? super java.lang.Throwable>	RxJavaPlugins.getErrorHandler()	Returns the a hook consumer.

Methods in io.reactivex.rxjava3.plugins with parameters of type Consumer

Modifier and Type	Method	Description
static void	RxJavaPlugins.setErrorHandler(@Nullable Consumer<? super java.lang.Throwable> handler)	Sets the specific hook function.