Top Classes
[default module]

Package io.reactivex.rxjava3.internal.operators.flowable

Class Summary

Modifier and TypeClass and Description
pack-priv abstract class
AbstractBackpressureThrottlingSubscriber<
the upstream value type
T,
the downstream value type
R>

Abstract base class for operators that throttle excessive updates from upstream in case if downstream Subscriber is not ready to receive updates.

pack-priv abstract class
AbstractFlowableWithUpstream<
the upstream value type
T,
the output value type
R>

Abstract base class for operators that take an upstream source Publisher.

public class
BlockingFlowableIterable<T>

public class
BlockingFlowableLatest<
the value type emitted
T>

Wait for and iterate over the latest values of the source observable.

public class
BlockingFlowableMostRecent<
the value type
T>

Returns an Iterable that always returns the item most recently emitted by an Observable, or a seed value if no item has yet been emitted.

public class
BlockingFlowableNext<
the value type
T>

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

public class
FlowableAll<T>

public class
FlowableAllSingle<T>

public class
FlowableAmb<T>

public class
FlowableAny<T>

public class
FlowableAnySingle<T>

public class
FlowableAutoConnect<
the value type of the chain
T>

Wraps a ConnectableFlowable and calls its connect() method once the specified number of Subscribers have subscribed.

public class
FlowableBlockingSubscribe

Utility methods to consume a Publisher in a blocking manner with callbacks or Subscriber.

public class
FlowableBuffer<T, C extends Collection<? super T>>

public class
FlowableBufferBoundary<T, U extends Collection<? super T>, Open, Close>

public class
FlowableBufferExactBoundary<T, U extends Collection<? super T>, B>

public class
FlowableBufferTimed<T, U extends Collection<? super T>>

public class
FlowableCache<
the source element type
T>

An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.

public class
FlowableCollect<T, U>

public class
FlowableCollectSingle<T, U>

public class
FlowableCombineLatest<
the value type of the sources
T,
the result type
R>

Combines the latest values from multiple sources through a function.

public class
FlowableConcatArray<T>

public class
FlowableConcatMap<T, R>

public class
FlowableConcatMapEager<T, R>

public class
FlowableConcatMapEagerPublisher<
the input value type
T,
the output type
R>

ConcatMapEager which works with an arbitrary Publisher source.

public class
FlowableConcatMapScheduler<T, R>

public class
FlowableConcatWithCompletable<
the element type of the main source and output type
T>

Subscribe to a main Flowable first, then when it completes normally, subscribe to a Completable and terminate when it terminates.

public class
FlowableConcatWithMaybe<
the element type of the main source and output type
T>

Subscribe to a main Flowable first, then when it completes normally, subscribe to a Maybe, signal its success value followed by a completion or signal its error or completion signal as is.

public class
FlowableConcatWithSingle<
the element type of the main source and output type
T>

Subscribe to a main Flowable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.

public class
FlowableCount<T>

public class
FlowableCountSingle<T>

public class
FlowableCreate<T>

public class
FlowableDebounce<T, U>

public class
FlowableDebounceTimed<T>

public class
FlowableDefer<T>

public class
FlowableDelay<T>

public class
FlowableDelaySubscriptionOther<
the main type
T,
the other value type, ignored
U>

Delays the subscription to the main source until the other observable fires an event or completes.

public class
FlowableDematerialize<T, R>

public class
FlowableDetach<T>

public class
FlowableDistinct<T, K>

public class
FlowableDistinctUntilChanged<T, K>

public class
FlowableDoAfterNext<
the value type
T>

Calls a consumer after pushing the current item to the downstream.

public class
FlowableDoFinally<
the value type
T>

Execute an action after an onError, onComplete or a cancel event.

public class
FlowableDoOnEach<T>

public class
FlowableDoOnLifecycle<T>

public class
FlowableElementAt<T>

public class
FlowableElementAtMaybe<T>

public class
FlowableElementAtMaybePublisher<
the element type of the source
T>

Emits the indexth element from a Publisher as a Maybe.

public class
FlowableElementAtSingle<T>

public class
FlowableEmpty

A source Flowable that signals an onSubscribe() + onComplete() only.

public class
FlowableError<T>

public class
FlowableFilter<T>

public class
FlowableFlatMap<T, U>

public class
FlowableFlatMapCompletable<
the value type
T>

Maps a sequence of values into CompletableSources and awaits their termination.

public class
FlowableFlatMapCompletableCompletable<
the value type
T>

Maps a sequence of values into CompletableSources and awaits their termination.

public class
FlowableFlatMapMaybe<
the source value type
T,
the result value type
R>

Maps upstream values into MaybeSources and merges their signals into one sequence.

public class
FlowableFlatMapMaybePublisher<
the source value type
T,
the result value type
R>

Maps upstream values into MaybeSources and merges their signals into one sequence.

public class
FlowableFlatMapSingle<
the source value type
T,
the result value type
R>

Maps upstream values into SingleSources and merges their signals into one sequence.

public class
FlowableFlatMapSinglePublisher<
the source value type
T,
the result value type
R>

Maps upstream values into SingleSources and merges their signals into one sequence.

public class
FlowableFlattenIterable<T, R>

public class
FlowableFromAction<
the value type
T>

Executes an Action and signals its exception or completes normally.

public class
FlowableFromArray<T>

public class
FlowableFromCallable<T>

public class
FlowableFromCompletable<
the value type
T>

Wrap a Completable into a Flowable.

public class
FlowableFromFuture<T>

public class
FlowableFromIterable<T>

public class
FlowableFromObservable<T>

public class
FlowableFromPublisher<T>

public class
FlowableFromRunnable<
the value type
T>

Executes an Runnable and signals its exception or completes normally.

public class
FlowableFromSupplier<
the value type and element type returned by the supplier and the flow
T>

Call a Supplier for each incoming Subscriber and signal the returned value or the thrown exception.

public class
FlowableGenerate<T, S>

public class
FlowableGroupBy<T, K, V>

public class
FlowableGroupJoin<TLeft, TRight, TLeftEnd, TRightEnd, R>

public class
FlowableHide<
the value type
T>

Hides the identity of the wrapped Flowable and its Subscription.

public class
FlowableIgnoreElements<T>

public class
FlowableIgnoreElementsCompletable<T>

public class
FlowableInternalHelper

Helper utility class to support Flowable with inner classes.

public class
FlowableInterval

public class
FlowableIntervalRange

public class
FlowableJoin<TLeft, TRight, TLeftEnd, TRightEnd, R>

public class
FlowableJust<
the value type
T>

Represents a constant scalar value.

public class
FlowableLastMaybe<
the value type
T>

Consumes the source Publisher and emits its last item or completes.

public class
FlowableLastSingle<
the value type
T>

Consumes the source Publisher and emits its last item or the defaultItem if empty.

public class
FlowableLift<
the downstream parameter type
R,
the upstream value type
T>

Allows lifting operators into a chain of Publishers.

public class
FlowableMap<T, U>

public class
FlowableMapNotification<T, R>

public class
FlowableMapPublisher<
the input value type
T,
the output value type
U>

Map working with an arbitrary Publisher source.

public class
FlowableMaterialize<T>

public class
FlowableMergeWithCompletable<
the element type of the Flowable
T>

Merges a Flowable and a Completable by emitting the items of the Flowable and waiting until both the Flowable and Completable complete normally.

public class
FlowableMergeWithMaybe<
the element type of the Observable
T>

Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.

public class
FlowableMergeWithSingle<
the element type of the Observable
T>

Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.

public class
FlowableNever

public class
FlowableObserveOn<T>

public class
FlowableOnBackpressureBuffer<T>

public class
FlowableOnBackpressureBufferStrategy<
the input and output value type
T>

Handle backpressure with a bounded buffer and custom strategy.

public class
FlowableOnBackpressureDrop<T>

public class
FlowableOnBackpressureError<T>

public class
FlowableOnBackpressureLatest<T>

public class
FlowableOnBackpressureReduce<T>

public class
FlowableOnBackpressureReduceWith<T, R>

public class
FlowableOnErrorComplete<
the value type
T>

Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.

public class
FlowableOnErrorNext<T>

public class
FlowableOnErrorReturn<T>

public class
FlowablePublish<
the element type
T>

Shares a single underlying connection to the upstream Publisher and multicasts events to all subscribed subscribers until the upstream completes or the connection is disposed.

public class
FlowablePublishMulticast<
the input value type
T,
the output value type
R>

Multicasts a Flowable over a selector function.

public class
FlowableRange

Emits a range of integer values.

public class
FlowableRangeLong

Emits a range of long values.

public class
FlowableReduce<
the value type
T>

Reduces a sequence via a function into a single value or signals NoSuchElementException for an empty source.

public class
FlowableReduceMaybe<
the value type
T>

Reduce a Flowable into a single value exposed as Single or signal NoSuchElementException.

public class
FlowableReduceSeedSingle<
the source value type
T,
the accumulated result type
R>

Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.

public class
FlowableReduceWithSingle<
the source value type
T,
the accumulated result type
R>

Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.

public class
FlowableRefCount<
the value type
T>

Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.

public class
FlowableRepeat<T>

public class
FlowableRepeatUntil<T>

public class
FlowableRepeatWhen<T>

public class
FlowableReplay<T>

public class
FlowableRetryBiPredicate<T>

public class
FlowableRetryPredicate<T>

public class
FlowableRetryWhen<T>

public class
FlowableSamplePublisher<T>

public class
FlowableSampleTimed<T>

public class
FlowableScalarXMap

Utility classes to work with scalar-sourced XMap operators (where X == { flat, concat, switch }).

public class
FlowableScan<T>

public class
FlowableScanSeed<T, R>

public class
FlowableSequenceEqual<T>

public class
FlowableSequenceEqualSingle<T>

public class
FlowableSerialized<T>

public class
FlowableSingle<T>

public class
FlowableSingleMaybe<T>

public class
FlowableSingleSingle<T>

public class
FlowableSkip<T>

public class
FlowableSkipLast<T>

public class
FlowableSkipLastTimed<T>

public class
FlowableSkipUntil<T, U>

public class
FlowableSkipWhile<T>

public class
FlowableSubscribeOn<
the value type emitted
T>

Subscribes to the source Flowable on the specified Scheduler and makes sure downstream requests are scheduled there as well.

public class
FlowableSwitchIfEmpty<T>

public class
FlowableSwitchMap<T, R>

public class
FlowableTake<T>

public class
FlowableTakeLast<T>

public class
FlowableTakeLastOne<T>

public class
FlowableTakeLastTimed<T>

public class
FlowableTakePublisher<
the value type
T>

Take with a generic Publisher source.

public class
FlowableTakeUntil<T, U>

public class
FlowableTakeUntilPredicate<T>

public class
FlowableTakeWhile<T>

public class
FlowableThrottleFirstTimed<T>

public class
FlowableThrottleLatest<
the upstream and downstream value type
T>

Emits the next or latest item when the given time elapses.

public class
FlowableTimeInterval<T>

public class
FlowableTimeout<T, U, V>

public class
FlowableTimeoutTimed<T>

public class
FlowableTimer

public class
FlowableToList<T, U extends Collection<? super T>>

public class
FlowableToListSingle<T, U extends Collection<? super T>>

public class
FlowableUnsubscribeOn<T>

public class
FlowableUsing<T, D>

public class
FlowableWindow<T>

public class
FlowableWindowBoundary<T, B>

public class
FlowableWindowBoundarySelector<T, B, V>

pack-priv class
FlowableWindowSubscribeIntercept<
the element type of the flow.
T>

Wrapper for a FlowableProcessor that detects an incoming subscriber.

public class
FlowableWindowTimed<T>

public class
FlowableWithLatestFrom<T, U, R>

public class
FlowableWithLatestFromMany<
the main sequence's type
T,
the output type
R>

Combines a main sequence of values with the latest from multiple other sequences via a selector function.

public class
FlowableZip<T, R>

public class
FlowableZipIterable<T, U, V>