Flowable
Flowable class that implements the Reactive Streams Publisher
Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
Reactive Streams operates with Publishers which Flowable extends. Many operators
therefore accept general Publishers directly and allow direct interoperation with other
Reactive Streams implementations.
The Flowable hosts the default buffer size of 128 elements for operators, accessible via bufferSize(),
that can be overridden globally via the system parameter rx3.buffer-size. Most operators, however, have
overloads that allow setting their internal buffer size explicitly.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
The Flowable follows the protocol
onSubscribe onNext* (onError | onComplete)?
Subscription instance provided to consumers through
Subscriber#onSubscribe(Subscription).
Unlike the Observable.subscribe() of version 1.x, subscribe(Subscriber) does not allow external cancellation
of a subscription and the Subscriber instance is expected to expose such capability if needed.
Flowables support backpressure and require Subscribers to signal demand via Subscription#request(long).
Example:
Disposable d = Flowable.just("Hello world!")
.delay(1, TimeUnit.SECONDS)
.subscribeWith(new DisposableSubscriber<String>() {
@Override public void onStart() {
System.out.println("Start!");
request(1);
}
@Override public void onNext(String t) {
System.out.println(t);
request(1);
}
@Override public void onError(Throwable t) {
t.printStackTrace();
}
@Override public void onComplete() {
System.out.println("Done!");
}
});
Thread.sleep(500);
// the sequence can now be cancelled via dispose()
d.dispose();
The Reactive Streams specification is relatively strict when defining interactions between Publishers and Subscribers, so much so
that there is a significant performance penalty due certain timing requirements and the need to prepare for invalid
request amounts via Subscription#request(long).
Therefore, RxJava has introduced the FlowableSubscriber interface that indicates the consumer can be driven with relaxed rules.
All RxJava operators are implemented with these relaxed rules in mind.
If the subscribing Subscriber does not implement this interface, for example, due to it being from another Reactive Streams compliant
library, the Flowable will automatically apply a compliance wrapper around it.
Flowable is an abstract class, but it is not advised to implement sources and custom operators by extending the class directly due
to the large amounts of Reactive Streams
rules to be followed to the letter. See the wiki for
some guidance if such custom implementations are necessary.
The recommended way of creating custom Flowables is by using the create(FlowableOnSubscribe, BackpressureStrategy) factory method:
Flowable<String> source = Flowable.create(new FlowableOnSubscribe<String>() {
@Override
public void subscribe(FlowableEmitter<String> emitter) throws Exception {
// signal an item
emitter.onNext("Hello");
// could be some blocking operation
Thread.sleep(1000);
// the consumer might have cancelled the flow
if (emitter.isCancelled()) {
return;
}
emitter.onNext("World");
Thread.sleep(1000);
// the end-of-sequence has to be signaled, otherwise the
// consumers may never finish
emitter.onComplete();
}
}, BackpressureStrategy.BUFFER);
System.out.println("Subscribe!");
source.subscribe(System.out::println);
System.out.println("Done!");
RxJava reactive sources, such as Flowable, are generally synchronous and sequential in nature. In the ReactiveX design, the location (thread)
where operators run is orthogonal to when the operators can work with data. This means that asynchrony and parallelism
has to be explicitly expressed via operators such as subscribeOn(Scheduler), observeOn(Scheduler) and parallel(). In general,
operators featuring a Scheduler parameter are introducing this type of asynchrony into the flow.
For more information see the ReactiveX documentation.
Observable, ParallelFlowable, io.reactivex.rxjava3.subscribers.DisposableSubscriber
| Modifier and Type | Field and Description |
|---|---|
| pack-priv static final int | BUFFER_SIZE
The default buffer size. |
| Access | Constructor and Description |
|---|---|
| public |
| Modifier and Type | Method and Description |
|---|---|
| public final @NonNull Single | |
| public static < the common element type T> @NonNull Flowable | Returns: the newFlowable instancean sources)Iterable of Publishers sources competing to react first. A subscription to each Publisher will
occur in the same order as in this Iterable.Mirrors the one |
| public static < the common element type T> @NonNull Flowable | Returns: the newFlowable instancean array of sources)Publisher sources competing to react first. A subscription to each Publisher will
occur in the same order as in this array.Mirrors the one |
| public final @NonNull Flowable | Returns: the newFlowable instancea other)Publisher competing to react first. A subscription to this provided Publisher will occur after subscribing
to the current Flowable.Mirrors the |
| public final @NonNull Single | Returns: the newSingle instancethe condition to test items emitted by the current predicate)FlowableReturns a Note this always emits |
| public final T | Returns: the newFlowable instanceReturns the first item emitted by this |
| public final T | Returns: the newFlowable instancea default value to return if this defaultItem)Flowable emits no itemsReturns the first item emitted by this |
| public final void | blockingForEach(@NonNull Consumer<? super T>
the onNext)Consumer to invoke for each item emitted by the FlowableConsumes the current |
| public final void | blockingForEach(@NonNull Consumer<? super T>
the onNext, int Consumer to invoke for each item emitted by the Flowablethe number of items to prefetch upfront, then 75% of it after 75% received bufferSize)Consumes the current |
| public final @NonNull Iterable | |
| public final @NonNull Iterable | Returns: the newIterable instancethe number of items to prefetch from the current bufferSize)FlowableConverts this |
| public final T | Returns: the newFlowable instanceReturns the last item emitted by this |
| public final T | Returns: the newFlowable instancea default value to return if this defaultItem)Flowable emits no itemsReturns the last item emitted by this |
| public final @NonNull Iterable | Returns: the newIterable instanceReturns an |
| public final @NonNull Iterable | Returns: the newIterable instancethe initial item that the initialItem)Iterable sequence will yield if this
Flowable has not yet emitted an itemReturns an |
| public final @NonNull Iterable | Returns: the newIterable instanceReturns an |
| public final T | Returns: the newFlowable instanceIf this |
| public final T | Returns: the newFlowable instancea default value to return if this defaultItem)Flowable emits no itemsIf this |
| public final @NonNull Stream | Returns: the newStream instanceCreates a sequential |
| public final @NonNull Stream | Returns: the newStream instancethe number of items to request from the upstream to limit the number of
in-flight items and item generation. prefetch)Creates a sequential |
| public final void | blockingSubscribe()
Runs the current |
| public final void | blockingSubscribe(@NonNull Consumer<? super T>
the callback action for each source value onNext)Subscribes to the source and calls the given callbacks on the current thread. |
| public final void | blockingSubscribe(@NonNull Consumer<? super T>
the callback action for each source value onNext, int the size of the buffer bufferSize)Subscribes to the source and calls the given callbacks on the current thread. |
| public final void | |
| public final void | |
| public final void | blockingSubscribe(@NonNull Consumer<? super T>
the callback action for each source value onNext, @NonNull Consumer<? super Throwable> the callback action for an error event onError, @NonNull Action the callback action for the completion event. onComplete)Subscribes to the source and calls the given callbacks on the current thread. |
| public final void | blockingSubscribe(@NonNull Consumer<? super T>
the callback action for each source value onNext, @NonNull Consumer<? super Throwable> the callback action for an error event onError, @NonNull Action the callback action for the completion event. onComplete, int the size of the buffer bufferSize)Subscribes to the source and calls the given callbacks on the current thread. |
| public final void | blockingSubscribe(@NonNull Subscriber<? super T>
the subscriber to forward events and calls to in the current thread subscriber)Subscribes to the source and calls the |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum number of items in each buffer before it should be emitted count)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum size of each buffer before it should be emitted count, int how many items emitted by the current skip)Flowable should be skipped before starting a new
buffer. Note that when skip and count are equal, this is the same operation as
buffer(int).Returns a |
| public final < the collection subclass type to buffer into U extends Collection | Returns: the newFlowable instancethe maximum size of each buffer before it should be emitted count, int how many items emitted by the current skip, @NonNull Supplier<U> Flowable should be skipped before starting a new
buffer. Note that when skip and count are equal, this is the same operation as
buffer(int).a factory function that returns an instance of the collection subclass to be used and returned
as the buffer bufferSupplier)Returns a |
| public final < the collection subclass type to buffer into U extends Collection | Returns: the newFlowable instancethe maximum number of items in each buffer before it should be emitted count, @NonNull Supplier<U> a factory function that returns an instance of the collection subclass to be used and returned
as the buffer bufferSupplier)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted timespan, long the period of time after which a new buffer will be created timeskip, @NonNull TimeUnit the unit of time that applies to the unit)timespan and timeskip argumentsReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted timespan, long the period of time after which a new buffer will be created timeskip, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Scheduler timespan and timeskip argumentsthe scheduler)Scheduler to use when determining the end and start of a bufferReturns a |
| public final < the collection subclass type to buffer into U extends Collection | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted timespan, long the period of time after which a new buffer will be created timeskip, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Scheduler timespan and timeskip argumentsthe scheduler, @NonNull Supplier<U> Scheduler to use when determining the end and start of a buffera factory function that returns an instance of the collection subclass to be used and returned
as the buffer bufferSupplier)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted and replaced with a new
buffer timespan, @NonNull TimeUnit the unit of time that applies to the unit)timespan argumentReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted and replaced with a new
buffer timespan, @NonNull TimeUnit the unit of time which applies to the unit, int timespan argumentthe maximum size of each buffer before it is emitted count)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted and replaced with a new
buffer timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler, int Scheduler to use when determining the end and start of a bufferthe maximum size of each buffer before it is emitted count)Returns a |
| public final < the collection subclass type to buffer into U extends Collection | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted and replaced with a new
buffer timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler, int Scheduler to use when determining the end and start of a bufferthe maximum size of each buffer before it is emitted count, @NonNull Supplier<U> a factory function that returns an instance of the collection subclass to be used and returned
as the buffer bufferSupplier, boolean if restartTimerOnMaxSize)true, the time window is restarted when the max capacity of the current buffer
is reachedReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each buffer collects items before it is emitted and replaced with a new
buffer timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler)Scheduler to use when determining the end and start of a bufferReturns a |
| public final < the element type of the buffer-opening TOpening, Publisherthe element type of the individual buffer-closing TClosing> @NonNull FlowablePublishers | Returns: the newFlowable instancethe openingIndicator, @NonNull Function<? super TOpening, @NonNull ? extends Publisher<? extends TClosing>> Publisher that, when it emits an item, causes a new buffer to be createdthe closingIndicator)Function that is used to produce a Publisher for every buffer created. When this
Publisher emits an item, the associated buffer is emitted.Returns a |
| public final < the element type of the buffer-opening TOpening, Publisherthe element type of the individual buffer-closing TClosing, Publishersthe collection subclass type to buffer into U extends Collection | Returns: the newFlowable instancethe openingIndicator, @NonNull Function<? super TOpening, @NonNull ? extends Publisher<? extends TClosing>> Publisher that, when it emits an item, causes a new buffer to be createdthe closingIndicator, @NonNull Supplier<U> Function that is used to produce a Publisher for every buffer created. When this
Publisher emits an item, the associated buffer is emitted.a factory function that returns an instance of the collection subclass to be used and returned
as the buffer bufferSupplier)Returns a |
| public final < the boundary value type (ignored) B> @NonNull Flowable | |
| public final < the boundary value type (ignored) B> @NonNull Flowable | Returns: the newFlowable instancethe boundary boundaryIndicator, int Publisherthe initial capacity of each buffer chunk initialCapacity)Returns a |
| public final < the boundary value type (ignored) B, the collection subclass type to buffer into U extends Collection | Returns: the newFlowable instancethe boundary boundaryIndicator, @NonNull Supplier<U> Publishera factory function that returns an instance of the collection subclass to be used and returned
as the buffer bufferSupplier)Returns a |
| public static int | Returns: the default internal buffer size.Returns the default internal buffer size used by most async operators. |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancehint for number of items to cache (for optimizing underlying data structure) initialCapacity)Returns a |
| public final < the output value type cast to U> @NonNull Flowable | Returns: the newFlowable instancethe target class type that clazz)cast will cast the items emitted by the current Flowable
into before emitting them from the resulting FlowableReturns a |
| public final < the accumulator and output type U> @NonNull Single | Returns: the newSingle instancethe mutable data structure that will collect the items initialItemSupplier, @NonNull BiConsumer<? super U, ? super T> a function that accepts the collector)state and an emitted item, and modifies state
accordinglyCollects items emitted by the finite source |
| public final < the non- R, null result typethe intermediate container type used for the accumulation A> @NonNull Single | Returns: the newSingle instancethe interface defining the container supplier, accumulator and finisher functions;
see collector)Collectors for some standard implementationsCollects the finite upstream's values into a container via a |
| public final < the accumulator and output type U> @NonNull Single | Returns: the newSingle instancethe mutable data structure that will collect the items initialItem, @NonNull BiConsumer<? super U, ? super T> a function that accepts the collector)state and an emitted item, and modifies state
accordinglyCollects items emitted by the finite source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines a collection of source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner, int Publishersthe internal buffer size and prefetch amount applied to every source bufferSize)FlowableCombines a collection of source |
| public static < the element type of the first source T1, the element type of the second source T2, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull BiFunction<? super T1, ? super T2, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines two source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Function3<? super T1, ? super T2, ? super T3, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines three source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the element type of the fourth source T4, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Publisher<? extends T4> Publisherthe fourth source source4, @NonNull Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines four source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the element type of the fourth source T4, the element type of the fifth source T5, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Publisher<? extends T4> Publisherthe fourth source source4, @NonNull Publisher<? extends T5> Publisherthe fifth source source5, @NonNull Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines five source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the element type of the fourth source T4, the element type of the fifth source T5, the element type of the sixth source T6, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Publisher<? extends T4> Publisherthe fourth source source4, @NonNull Publisher<? extends T5> Publisherthe fifth source source5, @NonNull Publisher<? extends T6> Publisherthe sixth source source6, @NonNull Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines six source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the element type of the fourth source T4, the element type of the fifth source T5, the element type of the sixth source T6, the element type of the seventh source T7, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Publisher<? extends T4> Publisherthe fourth source source4, @NonNull Publisher<? extends T5> Publisherthe fifth source source5, @NonNull Publisher<? extends T6> Publisherthe sixth source source6, @NonNull Publisher<? extends T7> Publisherthe seventh source source7, @NonNull Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines seven source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the element type of the fourth source T4, the element type of the fifth source T5, the element type of the sixth source T6, the element type of the seventh source T7, the element type of the eighth source T8, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Publisher<? extends T4> Publisherthe fourth source source4, @NonNull Publisher<? extends T5> Publisherthe fifth source source5, @NonNull Publisher<? extends T6> Publisherthe sixth source source6, @NonNull Publisher<? extends T7> Publisherthe seventh source source7, @NonNull Publisher<? extends T8> Publisherthe eighth source source8, @NonNull Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines eight source |
| public static < the element type of the first source T1, the element type of the second source T2, the element type of the third source T3, the element type of the fourth source T4, the element type of the fifth source T5, the element type of the sixth source T6, the element type of the seventh source T7, the element type of the eighth source T8, the element type of the ninth source T9, the combined output type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publisherthe second source source2, @NonNull Publisher<? extends T3> Publisherthe third source source3, @NonNull Publisher<? extends T4> Publisherthe fourth source source4, @NonNull Publisher<? extends T5> Publisherthe fifth source source5, @NonNull Publisher<? extends T6> Publisherthe sixth source source6, @NonNull Publisher<? extends T7> Publisherthe seventh source source7, @NonNull Publisher<? extends T8> Publisherthe eighth source source8, @NonNull Publisher<? extends T9> Publisherthe ninth source source9, @NonNull Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> Publisherthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines nine source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines a collection of source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner, int Publishersthe internal buffer size and prefetch amount applied to every source bufferSize)FlowableCombines a collection of source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines a collection of source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner, int Publishersthe internal buffer size and prefetch amount applied to every source bufferSize)FlowableCombines a collection of source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner)PublishersCombines a collection of source |
| public static < the common base type of source values T, the result type R> @NonNull Flowable | Returns: the newFlowable instancethe collection of source sources, @NonNull Function<? super Object[], ? extends R> Publishersthe aggregation function used to combine the items emitted by the source combiner, int Publishersthe internal buffer size and prefetch amount applied to every source bufferSize)FlowableCombines a collection of source |
| public final < the value type of the output R> @NonNull FlowablePublisher | Returns: the new composedFlowable instanceimplements the function that transforms the current composer)FlowableTransform the current |
| public static < the common value type of the sources T> @NonNull Flowable | |
| public static < the common element base type T> @NonNull Flowable | |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea sources, int Publisher that emits Publishersthe number of prefetch)Publishers to prefetch from the sources sequence.Returns a |
| public static < the common element base type T> @NonNull Flowable | |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be concatenateda source2, @NonNull Publisher<? extends T> Publisher to be concatenateda source3)Publisher to be concatenatedReturns a |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be concatenateda source2, @NonNull Publisher<? extends T> Publisher to be concatenateda source3, @NonNull Publisher<? extends T> Publisher to be concatenateda source4)Publisher to be concatenatedReturns a |
| public static < the common base value type T> @NonNull Flowable | Returns: the newFlowable instancethe array of source sources)PublishersConcatenates a variable number of |
| public static < the common base value type T> @NonNull Flowable | Returns: the newFlowable instancethe array of source sources)PublishersConcatenates a variable number of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behavioran array of sources)Publishers that need to be eagerly concatenatedConcatenates an array of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviorthe maximum number of concurrent subscriptions at a time, maxConcurrency, int Integer#MAX_VALUE
is interpreted as an indication to subscribe to all sources at oncethe number of elements to prefetch from each prefetch, @NonNull Publisher<? extends T>... Publisher sourcean array of sources)Publishers that need to be eagerly concatenatedConcatenates an array of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behavioran array of sources)Publishers that need to be eagerly concatenatedConcatenates an array of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviorthe maximum number of concurrent subscriptions at a time, maxConcurrency, int Integer#MAX_VALUE
is interpreted as indication to subscribe to all sources at oncethe number of elements to prefetch from each prefetch, @NonNull Publisher<? extends T>... Publisher sourcean array of sources)Publishers that need to be eagerly concatenatedConcatenates an array of |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable with the concatenating behaviorthe sources)Iterable sequence of PublishersConcatenates the |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable with the concatenating behaviorthe sources)Publisher sequence of PublishersConcatenates the |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable with the concatenating behaviorthe sources, int Publisher sequence of Publishersthe number of elements to prefetch from the outer prefetch, boolean Publisherif tillTheEnd)true, exceptions from the outer and all inner Publishers are delayed to the end
if false, exception from the outer Publisher is delayed till the current inner Publisher terminatesConcatenates the |
| public static < the value type T> @NonNull Flowable | |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources, int Publishers that need to be eagerly concatenatedthe maximum number of concurrently running inner maxConcurrency, int Publishers; Integer#MAX_VALUE
is interpreted as all inner Publishers can be active at the same timethe number of elements to prefetch from each inner prefetch)Publisher sourceConcatenates a sequence of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources)Publishers that need to be eagerly concatenatedConcatenates a |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources, int Publishers that need to be eagerly concatenatedthe maximum number of concurrently running inner maxConcurrency, int Publishers; Integer#MAX_VALUE
is interpreted as all inner Publishers can be active at the same timethe number of elements to prefetch from each inner prefetch)Publisher sourceConcatenates a |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources)Publishers that need to be eagerly concatenatedConcatenates a sequence of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources, int Publishers that need to be eagerly concatenatedthe maximum number of concurrently running inner maxConcurrency, int Publishers; Integer#MAX_VALUE
is interpreted as all inner Publishers can be active at the same timethe number of elements to prefetch from each inner prefetch)Publisher sourceConcatenates a sequence of |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources)Publishers that need to be eagerly concatenatedConcatenates a |
| public static < the value type T> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviora sequence of sources, int Publishers that need to be eagerly concatenatedthe maximum number of concurrently running inner maxConcurrency, int Publishers; Integer#MAX_VALUE
is interpreted as all inner Publishers can be active at the same timethe number of elements to prefetch from each inner prefetch)Publisher sourceConcatenates a |
| public final < the type of the inner R> @NonNull FlowablePublisher sources and thus the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper)Flowable, returns a
PublisherReturns a new |
| public final < the type of the inner R> @NonNull FlowablePublisher sources and thus the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, int Flowable, returns a
Publisherthe number of elements to prefetch from the current prefetch)FlowableReturns a new |
| public final < the type of the inner R> @NonNull FlowablePublisher sources and thus the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, int Flowable, returns a
Publisherthe number of elements to prefetch from the current prefetch, @NonNull Scheduler Flowablethe scheduler where the scheduler)mapper function will be executedReturns a new |
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with the upstream item and should return
a mapper)CompletableSource to become the next source to
be subscribed toMaps the upstream items into |
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with the upstream item and should return
a mapper, int CompletableSource to become the next source to
be subscribed toThe number of upstream items to prefetch so that fresh items are
ready to be mapped when a previous prefetch)CompletableSource terminates.
The operator replenishes after half of the prefetch amount has been consumed
and turned into CompletableSources.Maps the upstream items into |
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with the upstream item and should return
a mapper)CompletableSource to become the next source to
be subscribed toMaps the upstream items into |
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with the upstream item and should return
a mapper, boolean CompletableSource to become the next source to
be subscribed toIf tillTheEnd)true, errors from this Flowable or any of the
inner CompletableSources are delayed until all
of them terminate. If false, an error from this
Flowable is delayed until the current inner
CompletableSource terminates and only then is
it emitted to the downstream.Maps the upstream items into |
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with the upstream item and should return
a mapper, boolean CompletableSource to become the next source to
be subscribed toIf tillTheEnd, int true, errors from this Flowable or any of the
inner CompletableSources are delayed until all
of them terminate. If false, an error from this
Flowable is delayed until the current inner
CompletableSource terminates and only then is
it emitted to the downstream.The number of upstream items to prefetch so that fresh items are
ready to be mapped when a previous prefetch)CompletableSource terminates.
The operator replenishes after half of the prefetch amount has been consumed
and turned into CompletableSources.Maps the upstream items into |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instance with the concatenation behaviorthe function that maps the items of this mapper)Publisher into the inner Publishers.Maps each of the items into a |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instance with the concatenation behaviorthe function that maps the items of this mapper, boolean Publisher into the inner Publishers.if tillTheEnd, int true, all errors from the outer and inner Publisher sources are delayed until the end,
if false, an error from the main source is signaled when the current inner Publisher source terminatesthe number of elements to prefetch from the current prefetch)FlowableMaps each of the items into a |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instance with the concatenation behaviorthe function that maps the items of this mapper, boolean Publisher into the inner Publishers.if tillTheEnd, int true, all errors from the outer and inner Publisher sources are delayed until the end,
if false, an error from the main source is signaled when the current inner Publisher source terminatesthe number of elements to prefetch from the current prefetch, @NonNull Scheduler Flowablethe scheduler where the scheduler)mapper function will be executedMaps each of the upstream items into a |
| public final < the value type R> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviorthe function that maps a sequence of values into a sequence of mapper)Publishers that will be
eagerly concatenatedMaps a sequence of values into |
| public final < the value type R> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviorthe function that maps a sequence of values into a sequence of mapper, int Publishers that will be
eagerly concatenatedthe maximum number of concurrent subscribed maxConcurrency, int Publishershints about the number of expected values from each inner prefetch)Publisher, must be positiveMaps a sequence of values into |
| public final < the value type R> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviorthe function that maps a sequence of values into a sequence of mapper, boolean Publishers that will be
eagerly concatenatedif tillTheEnd)true, all errors from the outer and inner Publisher sources are delayed until the end,
if false, an error from the main source is signaled when the current inner Publisher source terminatesMaps a sequence of values into |
| public final < the value type R> @NonNull Flowable | Returns: the newFlowable instance with the specified concatenation behaviorthe function that maps a sequence of values into a sequence of mapper, boolean Publishers that will be
eagerly concatenatedif tillTheEnd, int true, exceptions from the current Flowable and all the inner Publishers are delayed until
all of them terminate, if false, exception from the current Flowable is delayed until the
currently running Publisher terminatesthe maximum number of concurrent subscribed maxConcurrency, int Publishersthe number of elements to prefetch from each source prefetch)PublisherMaps a sequence of values into |
| public final < the type of item emitted by the resulting U> @NonNull FlowableFlowable | Returns: the newFlowable instancea function that returns an mapper)Iterable sequence of values for when given an item emitted by the
current FlowableReturns a |
| public final < the type of item emitted by the resulting U> @NonNull FlowableFlowable | Returns: the newFlowable instancea function that returns an mapper, int Iterable sequence of values for when given an item emitted by the
current Flowablethe number of elements to prefetch from the current prefetch)FlowableReturns a |
| public final < the result type of the inner R> @NonNull FlowableMaybeSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper)MaybeSource to become the next source to
be subscribed toMaps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableMaybeSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper, int MaybeSource to become the next source to
be subscribed toThe number of upstream items to prefetch so that fresh items are
ready to be mapped when a previous prefetch)MaybeSource terminates.
The operator replenishes after half of the prefetch amount has been consumed
and turned into MaybeSources.Maps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableMaybeSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper)MaybeSource to become the next source to
be subscribed toMaps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableMaybeSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper, boolean MaybeSource to become the next source to
be subscribed toIf tillTheEnd)true, errors from this Flowable or any of the
inner MaybeSources are delayed until all
of them terminate. If false, an error from this
Flowable is delayed until the current inner
MaybeSource terminates and only then is
it emitted to the downstream.Maps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableMaybeSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper, boolean MaybeSource to become the next source to
be subscribed toIf tillTheEnd, int true, errors from this Flowable or any of the
inner MaybeSources are delayed until all
of them terminate. If false, an error from this
Flowable is delayed until the current inner
MaybeSource terminates and only then is
it emitted to the downstream.The number of upstream items to prefetch so that fresh items are
ready to be mapped when a previous prefetch)MaybeSource terminates.
The operator replenishes after half of the prefetch amount has been consumed
and turned into MaybeSources.Maps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableSingleSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper)SingleSource to become the next source to
be subscribed toMaps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableSingleSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper, int SingleSource to become the next source to
be subscribed toThe number of upstream items to prefetch so that fresh items are
ready to be mapped when a previous prefetch)SingleSource terminates.
The operator replenishes after half of the prefetch amount has been consumed
and turned into SingleSources.Maps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableSingleSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper)SingleSource to become the next source to
be subscribed toMaps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableSingleSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper, boolean SingleSource to become the next source to
be subscribed toIf tillTheEnd)true, errors from this Flowable or any of the
inner SingleSources are delayed until all
of them terminate. If false, an error from this
Flowable is delayed until the current inner
SingleSource terminates and only then is
it emitted to the downstream.Maps the upstream items into |
| public final < the result type of the inner R> @NonNull FlowableSingleSources | Returns: the newFlowable instancethe function called with the upstream item and should return
a mapper, boolean SingleSource to become the next source to
be subscribed toIf tillTheEnd, int true, errors from this Flowable or any of the
inner SingleSources are delayed until all
of them terminate. If false, an error from this
Flowable is delayed until the current inner
SingleSource terminates and only then is
it emitted to the downstream.The number of upstream items to prefetch so that fresh items are
ready to be mapped when a previous prefetch)SingleSource terminates.
The operator replenishes after half of the prefetch amount has been consumed
and turned into SingleSources.Maps the upstream items into |
| public final < the element type of the R> @NonNull FlowableStreams and the result | Returns: the newFlowable instancethe function that receives an upstream item and should return a mapper)Stream whose elements
will be emitted to the downstreamMaps each upstream item into a |
| public final < the element type of the R> @NonNull FlowableStreams and the result | Returns: the newFlowable instancethe function that receives an upstream item and should return a mapper, int Stream whose elements
will be emitted to the downstreamthe number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received prefetch)Maps each upstream item into a |
| public final @NonNull Flowable | Returns: the newFlowable instancea other)Publisher to be concatenated after the currentReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other)SingleSource whose signal should be emitted after this Flowable completes normally.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other)MaybeSource whose signal should be emitted after this Flowable completes normally.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other)CompletableSource to subscribe to once the current Flowable completes normallyReturns a |
| public final @NonNull Single | |
| public final @NonNull Single | |
| public static < the element type T> @NonNull Flowable | Returns: the newFlowable instancethe emitter that is called when a source, @NonNull BackpressureStrategy Subscriber subscribes to the returned Flowablethe backpressure mode to apply if the downstream mode)Subscriber doesn't request (fast) enoughProvides an API (via a cold |
| public final < the debounce value type (ignored) U> @NonNull Flowable | Returns: the newFlowable instancefunction to retrieve a sequence that indicates the throttle duration for each item debounceIndicator)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the window of time that must pass after the emission of an item from the current
timeout, @NonNull TimeUnit Flowable in which it emits no items in order for the item to be emitted by the
resulting Flowablethe unit of time for the specified unit)timeoutReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time each item has to be "the most recent" of those emitted by the current timeout, @NonNull TimeUnit Flowable to
ensure that it's not droppedthe unit of time for the specified unit, @NonNull Scheduler timeoutthe scheduler)Scheduler to use internally to manage the timers that handle the timeout for each
itemReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time each item has to be "the most recent" of those emitted by the current timeout, @NonNull TimeUnit Flowable to
ensure that it's not droppedthe unit of time for the specified unit, @NonNull Scheduler timeoutthe scheduler, @NonNull Consumer<? super T> Scheduler to use internally to manage the timers that handle the timeout for each
itemcalled with the current entry when it has been replaced by a new one onDropped)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe item to emit if the current defaultItem)Flowable emits no itemsReturns a |
| public static < the type of the items emitted by the T> @NonNull FlowablePublisher | Returns: the newFlowable instancethe supplier)Publisher factory function to invoke for each Subscriber that subscribes to the
resulting FlowableReturns a |
| public final < the item delay value type (ignored) U> @NonNull Flowable | Returns: the newFlowable instancea function that returns a itemDelayIndicator)Publisher for each item emitted by the current Flowable, which is
then used to delay the emission of that item by the resulting Flowable until the Publisher
returned from itemDelay emits an itemReturns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe delay to shift the source by time, @NonNull TimeUnit the unit, boolean TimeUnit in which period is definedif delayError)true, the upstream exception is signaled with the given delay, after all preceding normal elements,
if false, the upstream exception is signaled immediatelyReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe delay to shift the source by time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler delaythe scheduler)Scheduler to use for delayingReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe delay to shift the source by time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler delaythe scheduler, boolean Scheduler to use for delayingif delayError)true, the upstream exception is signaled with the given delay, after all preceding normal elements,
if false, the upstream exception is signaled immediatelyReturns a |
| public final < the subscription delay value type (ignored) U, the item delay value type (ignored) V> @NonNull Flowable | Returns: the newFlowable instancea function that returns a subscriptionIndicator, @NonNull Function<? super T, @NonNull ? extends Publisher<V>> Publisher that triggers the subscription to the current Flowable
once it emits any itema function that returns a itemDelayIndicator)Publisher for each item emitted by the current Flowable, which is
then used to delay the emission of that item by the resulting Flowable until the Publisher
returned from itemDelay emits an itemReturns a |
| public final < the value type of the other U> @NonNull FlowablePublisher, irrelevant | Returns: the newFlowable instancethe other subscriptionIndicator)Publisher that should trigger the subscription
to this Publisher.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to delay the subscription time, @NonNull TimeUnit the time unit of unit)delayReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to delay the subscription time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler delaythe scheduler)Scheduler on which the waiting and subscription will happenReturns a |
| public final < the output value type R> @NonNull Flowable | Returns: the newFlowable instancefunction that returns the upstream item and should return a selector)Notification to signal
the corresponding Subscriber event to the downstream.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public final < the key type K> @NonNull Flowable | Returns: the newFlowable instancea function that projects an emitted item to a key value that is used to decide whether an item
is distinct from another one or not keySelector)Returns a |
| public final < the key type K> @NonNull Flowable | Returns: the newFlowable instancea function that projects an emitted item to a key value that is used to decide whether an item
is distinct from another one or not keySelector, @NonNull Supplier<? extends Collection<? super K>> function called for each individual collectionSupplier)Subscriber to return a Collection subtype for holding the extracted
keys and whose add() method's return indicates uniqueness.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public final < the key type K> @NonNull Flowable | Returns: the newFlowable instancea function that projects an emitted item to a key value that is used to decide whether an item
is distinct from another one or not keySelector)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe function that receives the previous item and the current item and is
expected to return comparer)true if the two are equal, thus skipping the current value.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe onAfterNext)Consumer that will be called after emitting an item from upstream to the downstreamCalls the specified consumer with the current item after this item has been emitted to the downstream. |
| public final @NonNull Flowable | Returns: the newFlowable instancean onAfterTerminate)Action to be invoked when the current Flowable finishesRegisters an |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe action that gets called when the current onCancel)Flowable's Subscription is canceledCalls the cancel |
| public final @NonNull Flowable | Returns: the newFlowable instancethe action to invoke when the current onComplete)Flowable calls onCompleteInvokes an |
| private @NonNull Flowable | Returns: the newFlowable instancethe onError, Action onComplete, Action Consumer to invoke when the current Flowable calls onErrorthe onAfterTerminate)Action to invoke when the current Flowable calls onAfterTerminateCalls the appropriate onXXX consumer (shared between all subscribers) whenever a signal with the same type passes through, before forwarding them to downstream. |
| public final @NonNull Flowable | Returns: the newFlowable instancethe action to invoke for each item emitted by the current onNotification)FlowableInvokes a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe subscriber)Subscriber to be notified about onNext, onError and onComplete events on its
respective methods before the actual downstream Subscriber gets notified.Calls the appropriate methods of the given |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancea onRequest, @NonNull Action LongConsumer called with the request amount sent via Subscription#request(long)called when the downstream cancels the onCancel)Subscription via Subscription#cancel()Calls the appropriate |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe action that gets called when a onRequest)Subscriber requests items from the current
FlowableCalls the given |
| public final @NonNull Flowable | Returns: the newFlowable instanceCalls the given |
| public final @NonNull Flowable | Returns: the newFlowable instancethe action to invoke when the current onTerminate)Flowable calls onComplete or onErrorCalls the given |
| public final @NonNull Maybe | |
| public final @NonNull Single | |
| public final @NonNull Single | Returns: the newSingle instancethe zero-based index of the item to retrieve index)Returns a |
| public static < the type of the items (ostensibly) emitted by the T> @NonNull FlowablePublisher | Returns: the sharedFlowable instanceReturns a |
| public static < the type of the items (ostensibly) emitted by the resulting T> @NonNull FlowableFlowable | |
| public static < the type of the items (ostensibly) emitted by the resulting T> @NonNull FlowableFlowable | |
| public final @NonNull Flowable | |
| public final @NonNull Single | |
| public final @NonNull Maybe | Returns: the newMaybe instanceReturns a |
| public final @NonNull Single | Returns: the newSingle instanceReturns a |
| public final @NonNull CompletionStage | Returns: the newCompletionStage instanceSignals the first upstream item or a |
| public final @NonNull CompletionStage | Returns: the newCompletionStage instancethe item to signal if the upstream is empty defaultItem)Signals the first upstream item (or the default item if the upstream is empty) via
a |
| public final < the value type of the inner R> @NonNull FlowablePublishers and the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper)Flowable, returns a
PublisherReturns a |
| public final < the value type of the inner R> @NonNull FlowablePublishers and the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, boolean Flowable, returns a
Publisherif delayErrors)true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate
if false, the first one signaling an exception will terminate the whole sequence immediatelyReturns a |
| public final < the value type of the inner R> @NonNull FlowablePublishers and the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, int Flowable, returns a
Publisherthe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyReturns a |
| public final < the value type of the inner R> @NonNull FlowablePublishers and the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, boolean Flowable, returns a
Publisherif delayErrors, int true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate
if false, the first one signaling an exception will terminate the whole sequence immediatelythe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyReturns a |
| public final < the value type of the inner R> @NonNull FlowablePublishers and the output type | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, boolean Flowable, returns a
Publisherif delayErrors, int true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate
if false, the first one signaling an exception will terminate the whole sequence immediatelythe maximum number of maxConcurrency, int Publishers that may be subscribed to concurrentlythe number of elements to prefetch from each inner bufferSize)PublisherReturns a |
| public final < the result type R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a onNextMapper, @NonNull Function<? super Throwable, @NonNull ? extends Publisher<? extends R>> Publisher to merge for each item emitted by the current Flowablea function that returns a onErrorMapper, @NonNull Supplier<? extends Publisher<? extends R>> Publisher to merge for an onError notification from the current
Flowablea function that returns a onCompleteSupplier)Publisher to merge for an onComplete notification from the current
FlowableReturns a |
| public final < the result type R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a onNextMapper, @NonNull Function<Throwable, @NonNull ? extends Publisher<? extends R>> Publisher to merge for each item emitted by the current Flowablea function that returns a onErrorMapper, @NonNull Supplier<? extends Publisher<? extends R>> Publisher to merge for an onError notification from the current
Flowablea function that returns a onCompleteSupplier, int Publisher to merge for an onComplete notification from the current
Flowablethe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyReturns a |
| public final < the type of items emitted by the inner U, Publishersthe type of items emitted by the combiner function R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a mapper, @NonNull BiFunction<? super T, ? super U, ? extends R> Publisher for each item emitted by the current Flowablea function that combines one item emitted by each of the source and collection combiner)Publishers and
returns an item to be emitted by the resulting FlowableReturns a |
| public final < the type of items emitted by the inner U, Publishersthe type of items emitted by the combiner functions R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a mapper, @NonNull BiFunction<? super T, ? super U, ? extends R> Publisher for each item emitted by the current Flowablea function that combines one item emitted by each of the source and collection combiner, boolean Publishers and
returns an item to be emitted by the resulting Flowableif delayErrors)true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate
if false, the first one signaling an exception will terminate the whole sequence immediatelyReturns a |
| public final < the type of items emitted by the inner U, Publishersthe type of items emitted by the combiner function R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a mapper, @NonNull BiFunction<? super T, ? super U, ? extends R> Publisher for each item emitted by the current Flowablea function that combines one item emitted by each of the source and collection combiner, boolean Publishers and
returns an item to be emitted by the resulting Flowableif delayErrors, int true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate
if false, the first one signaling an exception will terminate the whole sequence immediatelythe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyReturns a |
| public final < the type of items emitted by the inner U, Publishersthe type of items emitted by the combiner function R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a mapper, @NonNull BiFunction<? super T, ? super U, ? extends R> Publisher for each item emitted by the current Flowablea function that combines one item emitted by each of the source and collection combiner, boolean Publishers and
returns an item to be emitted by the resulting Flowableif delayErrors, int true, exceptions from the current Flowable and all inner Publishers are delayed until all of them terminate
if false, the first one signaling an exception will terminate the whole sequence immediatelythe maximum number of maxConcurrency, int Publishers that may be subscribed to concurrentlythe number of elements to prefetch from the inner bufferSize)Publishers.Returns a |
| public final < the type of items emitted by the inner U, Publishersthe type of items emitted by the combiner function R> @NonNull Flowable | Returns: the newFlowable instancea function that returns a mapper, @NonNull BiFunction<? super T, ? super U, ? extends R> Publisher for each item emitted by the current Flowablea function that combines one item emitted by each of the source and collection combiner, int Publishers and
returns an item to be emitted by the resulting Flowablethe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyReturns a |
| public final @NonNull Completable | Returns: the newCompletable instancethe function that received each source value and transforms them into mapper)CompletableSources.Maps each element of the upstream |
| public final @NonNull Completable | Returns: the newCompletable instancethe function that received each source value and transforms them into mapper, boolean CompletableSources.if delayErrors, int true, errors from the upstream and inner CompletableSources are delayed until each of them
terminates.the maximum number of active subscriptions to the maxConcurrency)CompletableSources.Maps each element of the upstream |
| public final < the output type and the element type of the U> @NonNull FlowableIterables | Returns: the newFlowable instancea function that returns an mapper)Iterable sequence of values for when given an item emitted by the
current FlowableMerges |
| public final < the type of item emitted by the resulting U> @NonNull FlowableIterable | Returns: the newFlowable instancea function that returns an mapper, int Iterable sequence of values for when given an item emitted by the
current Flowablethe number of elements to prefetch from the current bufferSize)FlowableMerges |
| public final < the element type of the U, Iterablesthe output type as determined by the V> @NonNull FlowableresultSelector function | Returns: the newFlowable instancea function that returns an mapper, @NonNull BiFunction<? super T, ? super U, ? extends V> Iterable sequence of values for each item emitted by the current
Flowablea function that returns an item based on the item emitted by the current combiner)Flowable and the
Iterable returned for that item by the collectionSelectorMerges |
| public final < the element type of the inner U, Iterable sequencesthe type of item emitted by the resulting V> @NonNull FlowableFlowable | Returns: the newFlowable instancea function that returns an mapper, @NonNull BiFunction<? super T, ? super U, ? extends V> Iterable sequence of values for when given an item emitted by the
current Flowablea function that returns an item based on the item emitted by the current combiner, int Flowable and the
Iterable returned for that item by the collectionSelectorthe number of elements to prefetch from the current prefetch)FlowableMerges |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe function that received each source value and transforms them into mapper)MaybeSources.Maps each element of the upstream |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe function that received each source value and transforms them into mapper, boolean MaybeSources.if delayErrors, int true, errors from the upstream and inner MaybeSources are delayed until each of them
terminates.the maximum number of active subscriptions to the maxConcurrency)MaybeSources.Maps each element of the upstream |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe function that received each source value and transforms them into mapper)SingleSources.Maps each element of the upstream |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe function that received each source value and transforms them into mapper, boolean SingleSources.if delayErrors, int true, errors from the upstream and inner SingleSources are delayed until each of them
terminates.the maximum number of active subscriptions to the maxConcurrency)SingleSources.Maps each element of the upstream |
| public final < the element type of the R> @NonNull FlowableStreams and the result | Returns: the newFlowable instancethe function that receives an upstream item and should return a mapper)Stream whose elements
will be emitted to the downstreamMaps each upstream item into a |
| public final < the element type of the R> @NonNull FlowableStreams and the result | Returns: the newFlowable instancethe function that receives an upstream item and should return a mapper, int Stream whose elements
will be emitted to the downstreamthe number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received prefetch)Maps each upstream item into a |
| public final @NonNull Disposable | Returns: aDisposable that allows canceling an asynchronous sequenceConsumer to execute for each item.Subscribes to the current |
| public final @NonNull Disposable | Returns: aDisposable that allows canceling an asynchronous sequencePredicate to execute for each item.Subscribes to the current |
| public final @NonNull Disposable | Returns: aDisposable that allows canceling an asynchronous sequencePredicate to execute for each item.Consumer to execute when an error is emitted.Subscribes to the current |
| public final @NonNull Disposable | Returns: aDisposable that allows canceling an asynchronous sequencePredicate to execute for each item.Consumer to execute when an error is emitted.Action to execute when completion is signaled.Subscribes to the current |
| public static < the target type T> @NonNull Flowable | Returns: the newFlowable instancethe action)Action to run for each SubscriberReturns a |
| public static < the type of items in the array and the type of items to be emitted by the resulting T> @NonNull FlowableFlowable | |
| public static < the type of the item emitted by the T> @NonNull FlowablePublisher | Returns: the newFlowable instancea function, the execution of which should be deferred; callable)fromCallable will invoke this
function only when a Subscriber subscribes to the Publisher that fromCallable returnsReturns a |
| public static < the target type T> @NonNull Flowable | Returns: the newFlowable instancethe completableSource)CompletableSource to convert fromWraps a |
| public static < the element type of the T> @NonNull FlowableCompletionStage | Returns: the newFlowable instancethe stage)CompletionStage to convert to Flowable and signal its terminal value or errorSignals the completion value or error of the given (hot) |
| public static < the type of object that the T> @NonNull FlowableFuture returns, and also the type of item to be emitted by
the resulting Flowable | Returns: the newFlowable instancethe source future)Future |
| public static < the type of object that the T> @NonNull FlowableFuture returns, and also the type of item to be emitted by
the resulting Flowable | |
| public static < the type of items in the T> @NonNull FlowableIterable sequence and the type of items to be emitted by the
resulting Flowable | Returns: the newFlowable instancethe source source)Iterable sequenceConverts an |
| public static < the value type of the T> @NonNull FlowableMaybeSource element | Returns: the newFlowable instancethe maybe)MaybeSource instance to subscribe to, not nullReturns a |
| public static < the element type of the source and resulting sequence T> @NonNull Flowable | Returns: the newFlowable instancethe source, @NonNull BackpressureStrategy ObservableSource to convertthe backpressure strategy to apply strategy)Converts the given |
| public static < the element type of the optional value T> @NonNull Flowable | Returns: the newFlowable instancethe optional value to convert into a optional)FlowableConverts the existing value of the provided optional into a |
| public static < the value type of the flow T> @NonNull Flowable | Returns: the newFlowable instancethe publisher)Publisher to convertConverts an arbitrary Reactive Streams |
| public static < the target type T> @NonNull Flowable | Returns: the newFlowable instancethe run)Runnable to run for each SubscriberReturns a |
| public static < the value type of the T> @NonNull FlowableSingleSource element | Returns: the newFlowable instancethe source)SingleSource instance to subscribe to, not nullReturns a |
| public static < the element type of the source T> @NonNull FlowableStream | Returns: the newFlowable instancethe stream)Stream of values to emitConverts a |
| public static < the type of the item emitted by the T> @NonNull FlowablePublisher | Returns: the newFlowable instancea function, the execution of which should be deferred; supplier)fromSupplier will invoke this
function only when a Subscriber subscribes to the Publisher that fromSupplier returnsReturns a |
| public static < the generated value type T> @NonNull Flowable | Returns: the newFlowable instancethe generator)Consumer called whenever a particular downstream Subscriber has
requested a value. The callback then should call onNext, onError or
onComplete to signal a value or a terminal event. Signaling multiple onNext
in a call will make the operator signal IllegalStateException.Returns a cold, synchronous, stateless and backpressure-aware generator of values. |
| public static < the generated value type T, the type of the per- S> @NonNull FlowableSubscriber state | Returns: the newFlowable instancethe initialState, @NonNull BiConsumer<S, Emitter<T>> Supplier to generate the initial state for each Subscriberthe generator)Consumer called with the current state whenever a particular downstream Subscriber has
requested a value. The callback then should call onNext, onError or
onComplete to signal a value or a terminal event. Signaling multiple onNext
in a call will make the operator signal IllegalStateException.Returns a cold, synchronous, stateful and backpressure-aware generator of values. |
| public static < the generated value type T, the type of the per- S> @NonNull FlowableSubscriber state | Returns: the newFlowable instancethe initialState, @NonNull BiConsumer<S, Emitter<T>> Supplier to generate the initial state for each Subscriberthe generator, @NonNull Consumer<? super S> Consumer called with the current state whenever a particular downstream Subscriber has
requested a value. The callback then should call onNext, onError or
onComplete to signal a value or a terminal event. Signaling multiple onNext
in a call will make the operator signal IllegalStateException.the disposeState)Consumer that is called with the current state when the generator
terminates the sequence or it gets canceledReturns a cold, synchronous, stateful and backpressure-aware generator of values. |
| public static < the generated value type T, the type of the per- S> @NonNull FlowableSubscriber state | Returns: the newFlowable instancethe initialState, @NonNull BiFunction<S, @NonNull Emitter<T>, S> Supplier to generate the initial state for each Subscriberthe generator)Function called with the current state whenever a particular downstream Subscriber has
requested a value. The callback then should call onNext, onError or
onComplete to signal a value or a terminal event and should return a (new) state for
the next invocation. Signaling multiple onNext
in a call will make the operator signal IllegalStateException.Returns a cold, synchronous, stateful and backpressure-aware generator of values. |
| public static < the generated value type T, the type of the per- S> @NonNull FlowableSubscriber state | Returns: the newFlowable instancethe initialState, @NonNull BiFunction<S, @NonNull Emitter<T>, S> Supplier to generate the initial state for each Subscriberthe generator, @NonNull Consumer<? super S> Function called with the current state whenever a particular downstream Subscriber has
requested a value. The callback then should call onNext, onError or
onComplete to signal a value or a terminal event and should return a (new) state for
the next invocation. Signaling multiple onNext
in a call will make the operator signal IllegalStateException.the disposeState)Consumer that is called with the current state when the generator
terminates the sequence or it gets canceledReturns a cold, synchronous, stateful and backpressure-aware generator of values. |
| public final < the key type K> @NonNull Flowable | Returns: the newFlowable instancea function that extracts the key for each item keySelector)Groups the items emitted by the current |
| public final < the key type K> @NonNull Flowable | Returns: the newFlowable instancea function that extracts the key for each item keySelector, boolean if delayError)true, the exception from the current Flowable is delayed in each group until that specific group emitted
the normal values; if false, the exception bypasses values in the groups and is reported immediately.Groups the items emitted by the current |
| public final < the key type K, the element type V> @NonNull Flowable | Returns: the newFlowable instancea function that extracts the key for each item keySelector, @NonNull Function<? super T, ? extends V> a function that extracts the return element for each item valueSelector)Groups the items emitted by the current |
| public final < the key type K, the element type V> @NonNull Flowable | Returns: the newFlowable instancea function that extracts the key for each item keySelector, @NonNull Function<? super T, ? extends V> a function that extracts the return element for each item valueSelector, boolean if delayError)true, the exception from the current Flowable is delayed in each group until that specific group emitted
the normal values; if false, the exception bypasses values in the groups and is reported immediately.Groups the items emitted by the current |
| public final < the key type K, the element type V> @NonNull Flowable | Returns: the newFlowable instancea function that extracts the key for each item keySelector, @NonNull Function<? super T, ? extends V> a function that extracts the return element for each item valueSelector, boolean if delayError, int true, the exception from the current Flowable is delayed in each group until that specific group emitted
the normal values; if false, the exception bypasses values in the groups and is reported immediately.the hint for how many bufferSize)GroupedFlowables and element in each GroupedFlowable should be bufferedGroups the items emitted by the current |
| public final < the key type K, the element type V> @NonNull Flowable | Returns: the newFlowable instancea function that extracts the key for each item keySelector, @NonNull Function<? super T, ? extends V> a function that extracts the return element for each item valueSelector, boolean if delayError, int true, the exception from the current Flowable is delayed in each group until that specific group emitted
the normal values; if false, the exception bypasses values in the groups and is reported immediately.the hint for how many bufferSize, @NonNull Function<? super Consumer<Object>, ? extends Map<K, Object>> GroupedFlowables and element in each GroupedFlowable should be bufferedThe factory used to create a map that will be used by the implementation to hold the
evictingMapFactory)GroupedFlowables. The evicting map created by this factory must
notify the provided Consumer<Object> with the entry value (not the key!) when
an entry in this map has been evicted. The next source emission will bring about the
completion of the evicted GroupedFlowables. See example above.Groups the items emitted by the current |
| public final < the value type of the right TRight, Publisher sourcethe element type of the left duration TLeftEnd, Publishersthe element type of the right duration TRightEnd, Publishersthe result type R> @NonNull Flowable | Returns: the newFlowable instancethe other other, @NonNull Function<? super T, @NonNull ? extends Publisher<TLeftEnd>> Publisher to correlate items from the current Flowable witha function that returns a leftEnd, @NonNull Function<? super TRight, @NonNull ? extends Publisher<TRightEnd>> Publisher whose emissions indicate the duration of the values of
the current Flowablea function that returns a rightEnd, @NonNull BiFunction<? super T, ? super Flowable<TRight>, ? extends R> Publisher whose emissions indicate the duration of the values of
the right Publishera function that takes an item emitted by each resultSelector)Publisher and returns the value to be emitted
by the resulting FlowableReturns a |
| public final @NonNull Flowable | |
| public final @NonNull Completable | Returns: the newCompletable instanceIgnores all items emitted by the current |
| public static @NonNull Flowable | Returns: the newFlowable instancethe initial delay time to wait before emitting the first value of 0L initialDelay, long the period of time between emissions of the subsequent numbers period, @NonNull TimeUnit the time unit for both unit)initialDelay and periodReturns a |
| public static @NonNull Flowable | Returns: the newFlowable instancethe initial delay time to wait before emitting the first value of 0L initialDelay, long the period of time between emissions of the subsequent numbers period, @NonNull TimeUnit the time unit for both unit, @NonNull Scheduler initialDelay and periodthe scheduler)Scheduler on which the waiting happens and items are emittedReturns a |
| public static @NonNull Flowable | |
| public static @NonNull Flowable | Returns: the newFlowable instancethe period size in time units (see below) period, @NonNull TimeUnit time units to use for the interval size unit, @NonNull Scheduler the scheduler)Scheduler to use for scheduling the itemsReturns a |
| public static @NonNull Flowable | Returns: the newFlowable instancethat start value of the range start, long the number of values to emit in total, if zero, the operator emits an count, long onComplete after the initial delay.the initial delay before signaling the first value (the start) initialDelay, long the period between subsequent values period, @NonNull TimeUnit the unit of measure of the unit)initialDelay and period amountsSignals a range of long values, the first after some initial delay and the rest periodically after. |
| public static @NonNull Flowable | Returns: the newFlowable instancethat start value of the range start, long the number of values to emit in total, if zero, the operator emits an count, long onComplete after the initial delay.the initial delay before signaling the first value (the start) initialDelay, long the period between subsequent values period, @NonNull TimeUnit the unit of measure of the unit, @NonNull Scheduler initialDelay and period amountsthe target scheduler)Scheduler where the values and terminal signals will be emittedSignals a range of long values, the first after some initial delay and the rest periodically after. |
| public final @NonNull Single | |
| public final < the value type of the right TRight, Publisher sourcethe element type of the left duration TLeftEnd, Publishersthe element type of the right duration TRightEnd, Publishersthe result type R> @NonNull Flowable | Returns: the newFlowable instancethe second other, @NonNull Function<? super T, @NonNull ? extends Publisher<TLeftEnd>> Publisher to join items froma function to select a duration for each item emitted by the current leftEnd, @NonNull Function<? super TRight, @NonNull ? extends Publisher<TRightEnd>> Flowable, used to
determine overlapa function to select a duration for each item emitted by the rightEnd, @NonNull BiFunction<? super T, ? super TRight, ? extends R> right Publisher, used to
determine overlapa function that computes an item to be emitted by the resulting resultSelector)Flowable for any two
overlapping items emitted by the two PublishersCorrelates the items emitted by two |
| public static < the type of that item T> @NonNull Flowable | Returns: the newFlowable instancethe item to emit item)Returns a |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public static < the type of these items T> @NonNull Flowable | |
| public final @NonNull Single | |
| public final @NonNull Maybe | Returns: the newMaybe instanceReturns a |
| public final @NonNull Single | Returns: the newSingle instanceReturns a |
| public final @NonNull CompletionStage | Returns: the newCompletionStage instanceSignals the last upstream item or a |
| public final @NonNull CompletionStage | Returns: the newCompletionStage instancethe item to signal if the upstream is empty defaultItem)Signals the last upstream item (or the default item if the upstream is empty) via
a |
| public final < the output value type R> @NonNull Flowable | Returns: the newFlowable instancethe lifter)FlowableOperator that receives the downstream's Subscriber and should return
a Subscriber with custom behavior to be used as the consumer for the current
Flowable.This method requires advanced knowledge about building operators, please consider
other standard composition methods first;
Returns a |
| public final < the output type R> @NonNull Flowable | Returns: the newFlowable instancea function to apply to each item emitted by the current mapper)FlowableReturns a |
| public final < the non- R> @NonNull Flowablenull output type | Returns: the newFlowable instancethe function that receives the upstream item and should return a non-empty mapper)Optional
to emit as the output or an empty Optional to skip to the next upstream valueMaps each upstream value into an |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe sources, int Iterable of Publishersthe maximum number of maxConcurrency, int Publishers that may be subscribed to concurrentlythe number of items to prefetch from each inner bufferSize)PublisherFlattens an |
| public static < the common element base type T> @NonNull Flowable | |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe sources, int Iterable of Publishersthe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyFlattens an |
| public static < the common element base type T> @NonNull Flowable | |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea sources, int Publisher that emits Publishersthe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyFlattens a |
| public static < the common element base type T> @NonNull Flowable | |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be mergeda source2, @NonNull Publisher<? extends T> Publisher to be mergeda source3)Publisher to be mergedFlattens three |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be mergeda source2, @NonNull Publisher<? extends T> Publisher to be mergeda source3, @NonNull Publisher<? extends T> Publisher to be mergeda source4)Publisher to be mergedFlattens four |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe maximum number of maxConcurrency, int Publishers that may be subscribed to concurrentlythe number of items to prefetch from each inner bufferSize, @NonNull Publisher<? extends T>... Publisherthe array of sources)PublishersFlattens an array of |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe array of sources)PublishersFlattens an array of |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe maximum number of maxConcurrency, int Publishers that may be subscribed to concurrentlythe number of items to prefetch from each inner bufferSize, @NonNull Publisher<? extends T>... Publisherthe array of sources)PublishersFlattens an array of |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe array of sources)PublishersFlattens an array of |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe sources)Iterable of PublishersFlattens an |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe sources, int Iterable of Publishersthe maximum number of maxConcurrency, int Publishers that may be subscribed to concurrentlythe number of items to prefetch from each inner bufferSize)PublisherFlattens an |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancethe sources, int Iterable of Publishersthe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyFlattens an |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea sources)Publisher that emits PublishersFlattens a |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea sources, int Publisher that emits Publishersthe maximum number of maxConcurrency)Publishers that may be subscribed to concurrentlyFlattens a |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be mergeda source2)Publisher to be mergedFlattens two |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be mergeda source2, @NonNull Publisher<? extends T> Publisher to be mergeda source3)Publisher to be mergedFlattens three |
| public static < the common element base type T> @NonNull Flowable | Returns: the newFlowable instancea source1, @NonNull Publisher<? extends T> Publisher to be mergeda source2, @NonNull Publisher<? extends T> Publisher to be mergeda source3, @NonNull Publisher<? extends T> Publisher to be mergeda source4)Publisher to be mergedFlattens four |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other)SingleSource whose success value to merge withMerges the sequence of items of this |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other)MaybeSource which provides a success value to merge with or completesMerges the sequence of items of this |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other)CompletableSource to await for completionRelays the items of this |
| public static < the type of items (not) emitted by the T> @NonNull FlowablePublisher | Returns: the sharedFlowable instanceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler)Scheduler to notify Subscribers onSignals the items and terminal signals of the current |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler, boolean Scheduler to notify Subscribers onindicates if the delayError)onError notification may not cut ahead of onNext notification on the other side of the
scheduling boundary. If true, a sequence ending in onError will be replayed in the same order as was received
from upstreamSignals the items and terminal signals of the current |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler, boolean Scheduler to notify Subscribers onindicates if the delayError, int onError notification may not cut ahead of onNext notification on the other side of the
scheduling boundary. If true, a sequence ending in onError will be replayed in the same order as was received
from upstreamthe size of the buffer. bufferSize)Signals the items and terminal signals of the current |
| public final < the output type U> @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instanceBuffers an unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instanceif delayError)true, an exception from the current Flowable is delayed until all buffered elements have been
consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping
any buffered elementBuffers an unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity)Buffers an limited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, boolean if delayError)true, an exception from the current Flowable is delayed until all buffered elements have been
consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping
any buffered elementBuffers an limited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, boolean if delayError, boolean true, an exception from the current Flowable is delayed until all buffered elements have been
consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping
any buffered elementif unbounded)true, the capacity value is interpreted as the internal "island" size of the unbounded bufferBuffers an optionally unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, boolean if delayError, boolean true, an exception from the current Flowable is delayed until all buffered elements have been
consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping
any buffered elementif unbounded, @NonNull Action true, the capacity value is interpreted as the internal "island" size of the unbounded bufferaction to execute if an item needs to be buffered, but there are no available slots. onOverflow)Buffers an optionally unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, boolean if delayError, boolean true, an exception from the current Flowable is delayed until all buffered elements have been
consumed by the downstream; if false, an exception is immediately signaled to the downstream, skipping
any buffered elementif unbounded, @NonNull Action true, the capacity value is interpreted as the internal "island" size of the unbounded bufferaction to execute if an item needs to be buffered, but there are no available slots. onOverflow, @NonNull Consumer<? super T> the onDropped)Consumer to be called with the item that could not be buffered due to capacity constraints.Buffers an optionally unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, @NonNull Action action to execute if an item needs to be buffered, but there are no available slots. Null is allowed. onOverflow)Buffers an limited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, @Nullable Action action to execute if an item needs to be buffered, but there are no available slots, onOverflow, @NonNull BackpressureOverflowStrategy null is allowed.how should the resulting overflowStrategy)Flowable react to buffer overflows, null is not allowed.Buffers an optionally unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of slots available in the buffer. capacity, @Nullable Action action to execute if an item needs to be buffered, but there are no available slots, onOverflow, @NonNull BackpressureOverflowStrategy null is allowed.how should the resulting overflowStrategy, @NonNull Consumer<? super T> Flowable react to buffer overflows, null is not allowed.the onDropped)Consumer to be called with the item that could not be buffered due to capacity constraints.Buffers an optionally unlimited number of items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instanceDrops items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instancethe action to invoke for each item dropped, should be fast and should never block. onDrop)Drops items from the current |
| public final @NonNull Flowable | Returns: the newFlowable instanceDrops all but the latest item emitted by the current |
| public final @NonNull Flowable | Returns: the newFlowable instancecalled with the current entry when it has been replaced by a new one onDropped)Drops all but the latest item emitted by the current |
| public final @NonNull Flowable | Returns: the newFlowable instancethe bi-function to call when there is more than one non-emitted value to downstream,
the first argument of the bi-function is previous item and the second one is currently
emitting from upstream reducer)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 |
| public final < the aggregate type emitted when the downstream requests more items R> @NonNull Flowable | Returns: the newFlowable instancethe factory to call to create new item of type R to pass it as the first argument to supplier, @NonNull BiFunction<R, ? super T, R> reducer.
It is called when previous returned value by reducer already sent to
downstream or the very first update from upstream received.the bi-function to call to reduce excessive updates which downstream is not ready to receive.
The first argument of type R is the object returned by reducer)supplier or result of previous
reducer invocation. The second argument of type T is the current update from upstream.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. |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe predicate to call when an predicate)Throwable is emitted which should return true
if the Throwable should be swallowed and replaced with an onComplete.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancea function that returns a fallbackSupplier)Publisher that will take over if the current Flowable encounters
an errorResumes the flow with a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe next fallback)Publisher source that will take over if the current Flowable encounters
an errorResumes the flow with the given |
| public final @NonNull Flowable | Returns: the newFlowable instancea function that returns a single value that will be emitted along with a regular itemSupplier)onComplete in case
the current Flowable signals an onError eventEnds the flow with a last item returned by a function for the |
| public final @NonNull Flowable | Returns: the newFlowable instancethe value that is emitted along with a regular item)onComplete in case the current
Flowable signals an exceptionEnds the flow with the given last item when the current |
| public final @NonNull Flowable | Returns: the newFlowable instance
the sequence is terminated or downstream cancelsNulls out references to the upstream producer and downstream |
| public final @NonNull ParallelFlowable | Returns: the newParallelFlowable instanceParallelizes the flow by creating multiple 'rails' (equal to the number of CPUs) and dispatches the upstream items to them in a round-robin fashion. |
| public final @NonNull ParallelFlowable | Returns: the newParallelFlowable instancethe number of 'rails' to use parallelism)Parallelizes the flow by creating the specified number of 'rails' and dispatches the upstream items to them in a round-robin fashion. |
| public final @NonNull ParallelFlowable | Returns: the newParallelFlowable instancethe number of 'rails' to use parallelism, int the number of items each 'rail' should prefetch prefetch)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. |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instanceReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea function that can use the multicasted source sequence as many times as needed, without
causing multiple subscriptions to the source sequence. selector)Subscribers to the given source will
receive all notifications of the source from the time of the subscription forward.Returns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea function that can use the multicasted source sequence as many times as needed, without
causing multiple subscriptions to the source sequence. selector, int Subscribers to the given source will
receive all notifications of the source from the time of the subscription forward.the number of elements to prefetch from the current prefetch)FlowableReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe number of elements to prefetch from the current bufferSize)FlowableReturns a |
| public static @NonNull Flowable | |
| public static @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe initial request amount, further request will happen after 75% of this value n)Requests |
| public final @NonNull Maybe | Returns: the newMaybe instancean accumulator function to be invoked on each item emitted by the current reducer)Flowable, whose
result will be used in the next accumulator callReturns a |
| public final < the accumulator and output value type R> @NonNull Single | Returns: the newSingle instancethe initial (seed) accumulator value seed, @NonNull BiFunction<R, ? super T, R> an accumulator function to be invoked on each item emitted by the current reducer)Flowable, the
result of which will be used in the next accumulator callReturns a |
| public final < the accumulator and output value type R> @NonNull Single | Returns: the newSingle instancethe seedSupplier, @NonNull BiFunction<R, ? super T, R> Supplier that provides the initial (seed) accumulator value for each individual Subscriberan accumulator function to be invoked on each item emitted by the current reducer)Flowable, the
result of which will be used in the next accumulator callReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe number of times the current times)Flowable items are repeated, a count of 0 will yield an empty
sequenceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancea boolean supplier that is called when the current stop)Flowable completes and unless it returns
false, the current Flowable is resubscribedReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancereceives a handler)Publisher of notifications with which a user can complete or error, aborting the repeat.Returns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instanceReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector)FlowableReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, int Flowablethe buffer size that limits the number of items the operator can replay bufferSize)Returns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, int Flowablethe buffer size that limits the number of items the operator can replay bufferSize, boolean if eagerTruncate)true, whenever the internal buffer is truncated to the given bufferSize, the
oldest item will be guaranteed dereferenced, thus avoiding unexpected retentionReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, int Flowablethe buffer size that limits the number of items the operator can replay bufferSize, long the duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit)timeReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, int Flowablethe buffer size that limits the number of items the operator can replay bufferSize, long the duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler)Scheduler that is the time source for the windowReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, int Flowablethe buffer size that limits the number of items the operator can replay bufferSize, long the duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler, boolean Scheduler that is the time source for the windowif eagerTruncate)true, whenever the internal buffer is truncated to the given bufferSize/age, the
oldest item will be guaranteed dereferenced, thus avoiding unexpected retentionReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, long Flowablethe duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit)timeReturns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, long Flowablethe duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler that is the time source for the window scheduler)Returns a |
| public final < the type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancea selector function, which can use the multicasted sequence as many times as needed, without
causing multiple subscriptions to the current selector, long Flowablethe duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler that is the time source for the window scheduler, boolean if eagerTruncate)true, whenever the internal buffer is truncated to the given age, the
oldest item will be guaranteed dereferenced, thus avoiding unexpected retentionReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe buffer size that limits the number of items that can be replayed bufferSize)Returns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe buffer size that limits the number of items that can be replayed bufferSize, boolean if eagerTruncate)true, whenever the internal buffer is truncated to the given bufferSize, the
oldest item will be guaranteed dereferenced, thus avoiding unexpected retentionReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe buffer size that limits the number of items that can be replayed bufferSize, long the duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit)timeReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe buffer size that limits the number of items that can be replayed bufferSize, long the duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler that is used as a time source for the window scheduler)Returns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe buffer size that limits the number of items that can be replayed bufferSize, long the duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler that is used as a time source for the window scheduler, boolean if eagerTruncate)true, whenever the internal buffer is truncated to the given bufferSize/age, the
oldest item will be guaranteed dereferenced, thus avoiding unexpected retentionReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit)timeReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler)Scheduler that is the time source for the windowReturns a |
| public final @NonNull ConnectableFlowable | Returns: the newConnectableFlowable instancethe duration of the window in which the replayed items must have been emitted time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler, boolean Scheduler that is the time source for the windowif eagerTruncate)true, whenever the internal buffer is truncated to the given bufferSize/age, the
oldest item will be guaranteed dereferenced, thus avoiding unexpected retentionReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe predicate that determines if a resubscription may happen in case of a specific exception
and retry count predicate)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe number of times to resubscribe if the current times)Flowable failsReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe number of times to resubscribe if the current times, @NonNull Predicate<@NonNull ? super Throwable> Flowable failsthe predicate called with the failure predicate)Throwable and should return true to trigger a retry.Retries at most times or until the predicate returns |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe function that should return stop)true to stop retryingRetries until the given stop function returns |
| public final @NonNull Flowable | Returns: the newFlowable instancereceives a handler)Publisher of notifications with which a user can complete or error, aborting the
retryReturns a |
| public final void | safeSubscribe(@NonNull Subscriber<? super T>
the incoming subscriber)Subscriber instanceSubscribes to the current |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe sampling rate period, @NonNull TimeUnit the unit, boolean TimeUnit in which period is definedif emitLast)true, and the upstream completes while there is still an unsampled item available,
that item is emitted to downstream before completion
if false, an unsampled last item is ignored.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe sampling rate period, @NonNull TimeUnit the unit, @NonNull Scheduler TimeUnit in which period is definedthe scheduler)Scheduler to use when samplingReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe sampling rate period, @NonNull TimeUnit the unit, @NonNull Scheduler TimeUnit in which period is definedthe scheduler, boolean Scheduler to use when samplingif emitLast)true and the upstream completes while there is still an unsampled item available,
that item is emitted to downstream before completion
if false, an unsampled last item is ignored.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe sampling rate period, @NonNull TimeUnit the unit, @NonNull Scheduler TimeUnit in which period is definedthe scheduler, boolean Scheduler to use when samplingif emitLast, @NonNull Consumer<? super T> true and the upstream completes while there is still an unsampled item available,
that item is emitted to downstream before completion
if false, an unsampled last item is ignored.called with the current entry when it has been replaced by a new one onDropped)Returns a |
| public final < the element type of the sampler U> @NonNull FlowablePublisher | Returns: the newFlowable instancethe sampler)Publisher to use for sampling the current FlowableReturns a |
| public final < the element type of the sampler U> @NonNull FlowablePublisher | Returns: the newFlowable instancethe sampler, boolean Publisher to use for sampling the current Flowableif emitLast)true and the upstream completes while there is still an unsampled item available,
that item is emitted to downstream before completion
if false, an unsampled last item is ignored.Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancean accumulator function to be invoked on each item emitted by the current accumulator)Flowable, whose
result will be emitted to Subscribers via onNext and used in the
next accumulator callReturns a |
| public final < the initial, accumulator and result type R> @NonNull Flowable | Returns: the newFlowable instancethe initial (seed) accumulator item initialValue, @NonNull BiFunction<R, ? super T, R> an accumulator function to be invoked on each item emitted by the current accumulator)Flowable, whose
result will be emitted to Subscribers via onNext and used in the
next accumulator callReturns a |
| public final < the initial, accumulator and result type R> @NonNull Flowable | Returns: the newFlowable instancea seedSupplier, @NonNull BiFunction<R, ? super T, R> Supplier that returns the initial (seed) accumulator item for each individual Subscriberan accumulator function to be invoked on each item emitted by the current accumulator)Flowable, whose
result will be emitted to Subscribers via onNext and used in the
next accumulator callReturns a |
| public static < the type of items emitted by each T> @NonNull SinglePublisher | Returns: the newSingle instancethe first source1, @NonNull Publisher<? extends T> Publisher to comparethe second source2)Publisher to compareReturns a |
| public static < the type of items emitted by each T> @NonNull SinglePublisher | Returns: the newSingle instancethe first source1, @NonNull Publisher<? extends T> Publisher to comparethe second source2, @NonNull BiPredicate<? super T, ? super T> Publisher to comparea function used to compare items emitted by each isEqual)PublisherReturns a |
| public static < the type of items emitted by each T> @NonNull SinglePublisher | Returns: the newSingle instancethe first source1, @NonNull Publisher<? extends T> Publisher to comparethe second source2, @NonNull BiPredicate<? super T, ? super T> Publisher to comparea function used to compare items emitted by each isEqual, int Publisherthe number of items to prefetch from the first and second source bufferSize)PublisherReturns a |
| public static < the type of items emitted by each T> @NonNull SinglePublisher | Returns: the newSingle instancethe first source1, @NonNull Publisher<? extends T> Publisher to comparethe second source2, int Publisher to comparethe number of items to prefetch from the first and second source bufferSize)PublisherReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceForces the current |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a new |
| public final @NonNull Single | |
| public final @NonNull Maybe | Returns: the newMaybe instanceReturns a |
| public final @NonNull Single | Returns: the newSingle instanceReturns a |
| public final @NonNull CompletionStage | Returns: the newCompletionStage instanceSignals the only expected upstream item, a |
| public final @NonNull CompletionStage | Returns: the newCompletionStage instancethe item to signal if the upstream is empty defaultItem)Signals the only expected upstream item (or the default item if the upstream is empty)
or signals |
| public final @NonNull Flowable | Returns: the newFlowable instancethe number of items to skip count)Returns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window to skip time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler)Scheduler on which the timed wait happensReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancenumber of items to drop from the end of the source sequence count)Returns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, boolean timeif delayError)true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler used as the time source scheduler)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler used as the time source scheduler, boolean if delayError)true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler used as the time source scheduler, boolean if delayError, int true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedthe hint about how many elements to expect to be skipped bufferSize)Returns a |
| public final < the element type of the other U> @NonNull FlowablePublisher | Returns: the newFlowable instancethe second other)Publisher that has to emit an item before the current Flowable's elements begin
to be mirrored by the resulting FlowableReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancea function to test each item emitted from the current predicate)FlowableReturns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancea function that compares two items emitted by the current comparator)Flowable and returns an Integer
that indicates their sort orderReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other other)CompletableSource to run firstReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other other)SingleSource to run firstReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe other other)MaybeSource to run firstReturns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe array of values to emit first items)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe item to emit first item)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancean items)Iterable that contains the items you want the resulting Flowable to emit firstReturns a |
| public final @NonNull Disposable | Returns: the newDisposable instance that allows cancelling the flowSubscribes to the current |
| public final @NonNull Disposable | Returns: the newDisposable instance that allows cancelling the flowthe onNext)Consumer<T> you have designed to accept emissions from the current FlowableSubscribes to the current |
| public final @NonNull Disposable | Returns: the newDisposable instance that allows cancelling the flowthe onNext, @NonNull Consumer<? super Throwable> Consumer<T> you have designed to accept emissions from the current Flowablethe onError)Consumer<Throwable> you have designed to accept any error notification from the
current FlowableSubscribes to the current |
| public final @NonNull Disposable | Returns: the newDisposable instance that allows cancelling the flowthe onNext, @NonNull Consumer<? super Throwable> Consumer<T> you have designed to accept emissions from the current Flowablethe onError, @NonNull Action Consumer<Throwable> you have designed to accept any error notification from the
current Flowablethe onComplete)Action you have designed to accept a completion notification from the
the current FlowableSubscribes to the current |
| public final @NonNull Disposable | Returns: theDisposable that allows disposing the particular subscription.the callback for upstream items onNext, @NonNull Consumer<? super Throwable> the callback for an upstream error if any onError, @NonNull Action the callback for the upstream completion if any onComplete, @NonNull DisposableContainer the container)DisposableContainer (such as CompositeDisposable) to add and remove the
created Disposable SubscriberWraps the given onXXX callbacks into a |
| public final void | subscribe(@NonNull Subscriber<? super T>
the subscriber)Subscriber that will consume signals from this PublisherImplements org. Publisher to start streaming data.
|
| public final void | subscribe(@NonNull FlowableSubscriber<? super T>
the subscriber)FlowableSubscriber that will consume signals from this FlowableEstablish a connection between this |
| protected abstract void | subscribeActual(@NonNull Subscriber<? super T>
the incoming subscriber)Subscriber, never nullOperator implementations (both source and intermediate) should implement this method that
performs the necessary business logic and handles the incoming |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler)Scheduler to perform subscription actions onAsynchronously subscribes |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler, boolean Scheduler to perform subscription actions onif requestOn)true, requests are rerouted to the given Scheduler as well (strong pipelining)
if false, requests coming from any thread are simply forwarded to
the upstream on the same thread (weak pipelining)Asynchronously subscribes |
| public final < the type of the E extends SubscriberSubscriber to use and return | Returns: the inputsubscriberthe subscriber)Subscriber (subclass) to use and return, not nullSubscribes a given |
| public final @NonNull Flowable | Returns: the newFlowable instancethe alternate other)Publisher to subscribe to if the source does not emit any itemsReturns a |
| public final < the element type of the inner R> @NonNull FlowablePublishers and the output | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper)Flowable, returns a
PublisherReturns a new |
| public final < the element type of the inner R> @NonNull FlowablePublishers and the output | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, int Flowable, returns a
Publisherthe number of elements to prefetch from the current active inner bufferSize)PublisherReturns a new |
| pack-priv <R> Flowable | switchMap0(Function<? super T, @NonNull ? extends Publisher<? extends R>> mapper, int bufferSize, boolean delayError)
|
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with each upstream item and should return a
mapper)CompletableSource to be subscribed to and awaited for
(non blockingly) for its terminal eventMaps the upstream values into |
| public final @NonNull Completable | Returns: the newCompletable instancethe function called with each upstream item and should return a
mapper)CompletableSource to be subscribed to and awaited for
(non blockingly) for its terminal eventMaps the upstream values into |
| public final < the element type of the inner R> @NonNull FlowablePublishers and the output | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper)Flowable, returns a
PublisherReturns a new |
| public final < the element type of the inner R> @NonNull FlowablePublishers and the output | Returns: the newFlowable instancea function that, when applied to an item emitted by the current mapper, int Flowable, returns a
Publisherthe number of elements to prefetch from the current active inner bufferSize)PublisherReturns a new |
| public final < the output value type R> @NonNull Flowable | Returns: the newFlowable instancethe function called with the current upstream event and should
return a mapper)MaybeSource to replace the current active inner source
and get subscribed to.Maps the upstream items into |
| public final < the output value type R> @NonNull Flowable | Returns: the newFlowable instancethe function called with the current upstream event and should
return a mapper)MaybeSource to replace the current active inner source
and get subscribed to.Maps the upstream items into |
| public final < the output value type R> @NonNull Flowable | Returns: the newFlowable instancethe function called with the current upstream event and should
return a mapper)SingleSource to replace the current active inner source
and get subscribed to.Maps the upstream items into |
| public final < the output value type R> @NonNull Flowable | Returns: the newFlowable instancethe function called with the current upstream event and should
return a mapper)SingleSource to replace the current active inner source
and get subscribed to.Maps the upstream items into |
| public static < the item type T> @NonNull Flowable | Returns: the newFlowable instancethe source sources, int Publisher that emits Publishersthe number of items to prefetch from the inner bufferSize)PublishersConverts a |
| public static < the item type T> @NonNull Flowable | |
| public static < the item type T> @NonNull Flowable | Returns: the newFlowable instancethe source sources)Publisher that emits PublishersConverts a |
| public static < the item type T> @NonNull Flowable | Returns: the newFlowable instancethe source sources, int Publisher that emits Publishersthe number of items to prefetch from the inner prefetch)PublishersConverts a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum number of items and the total request amount, non-negative.
Zero will immediately cancel the upstream on subscription and complete
the downstream. count)Returns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler)Scheduler used for time sourceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum number of items to emit from the end of the sequence of items emitted by the current
count)FlowableReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum number of items to emit count, long the length of the time window time, @NonNull TimeUnit the time unit of unit)timeReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum number of items to emit count, long the length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler)Scheduler that provides the timestamps for the observed itemsReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum number of items to emit count, long the length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler, boolean Scheduler that provides the timestamps for the observed itemsif delayError, int true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedthe hint about how many elements to expect to be last bufferSize)Returns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, boolean timeif delayError)true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler)Scheduler that provides the timestamps for the observed itemsReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler, boolean Scheduler that provides the timestamps for the observed itemsif delayError)true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the time window time, @NonNull TimeUnit the time unit of unit, @NonNull Scheduler timethe scheduler, boolean Scheduler that provides the timestamps for the observed itemsif delayError, int true, an exception signaled by the current Flowable is delayed until the regular elements are consumed
by the downstream; if false, an exception is immediately signaled and all regular elements droppedthe hint about how many elements to expect to be last bufferSize)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancea function that evaluates an item emitted by the current stopPredicate)Flowable and returns a BooleanReturns a |
| public final < the type of items emitted by U> @NonNull Flowableother | Returns: the newFlowable instancethe other)Publisher whose first emitted item or completion will cause takeUntil to stop emitting items
from the current FlowableReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancea function that evaluates an item emitted by the current predicate)Flowable and returns a BooleanReturns a |
| public final @NonNull TestSubscriber | Returns: the newTestSubscriber instanceCreates a |
| public final @NonNull TestSubscriber | Returns: the newTestSubscriber instancethe initial request amount, positive initialRequest)Creates a |
| public final @NonNull TestSubscriber | Returns: the newTestSubscriber instancethe initial request amount, positive initialRequest, boolean should the cancel)TestSubscriber be canceled before the subscription?Creates a |
| public final @NonNull Flowable | Returns: the newFlowable instancetime to wait before emitting another item after emitting the last item windowDuration, @NonNull TimeUnit the unit of time of unit)windowDurationReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancetime to wait before emitting another item after emitting the last item skipDuration, @NonNull TimeUnit the unit of time of unit, @NonNull Scheduler skipDurationthe scheduler)Scheduler to use internally to manage the timers that handle timeout for each
eventReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancetime to wait before emitting another item after emitting the last item skipDuration, @NonNull TimeUnit the unit of time of unit, @NonNull Scheduler skipDurationthe scheduler, @NonNull Consumer<? super T> Scheduler to use internally to manage the timers that handle timeout for each
eventcalled when an item doesn't get delivered to the downstream onDropped)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceduration of windows within which the last item emitted by the current intervalDuration, @NonNull TimeUnit Flowable will be
emittedthe unit of time of unit)intervalDurationReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceduration of windows within which the last item emitted by the current intervalDuration, @NonNull TimeUnit Flowable will be
emittedthe unit of time of unit, @NonNull Scheduler intervalDurationthe scheduler)Scheduler to use internally to manage the timers that handle timeout for each
eventReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceduration of windows within which the last item emitted by the current intervalDuration, @NonNull TimeUnit Flowable will be
emittedthe unit of time of unit, @NonNull Scheduler intervalDurationthe scheduler, @NonNull Consumer<? super T> Scheduler to use internally to manage the timers that handle timeout for each
eventcalled with the current entry when it has been replaced by a new one onDropped)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to wait after an item emission towards the downstream
before trying to emit the latest item from upstream again timeout, @NonNull TimeUnit the time unit unit)Throttles items from the upstream |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to wait after an item emission towards the downstream
before trying to emit the latest item from upstream again timeout, @NonNull TimeUnit the time unit unit, boolean If emitLast)true, the very last item from the upstream will be emitted
immediately when the upstream completes, regardless if there is
a timeout window active or not. If false, the very last
upstream item is ignored and the flow terminates.Throttles items from the upstream |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to wait after an item emission towards the downstream
before trying to emit the latest item from upstream again timeout, @NonNull TimeUnit the time unit unit, @NonNull Scheduler the scheduler)Scheduler where the timed wait and latest item
emission will be performedThrottles items from the upstream |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to wait after an item emission towards the downstream
before trying to emit the latest item from upstream again timeout, @NonNull TimeUnit the time unit unit, @NonNull Scheduler the scheduler, boolean Scheduler where the timed wait and latest item
emission will be performedIf emitLast)true, the very last item from the upstream will be emitted
immediately when the upstream completes, regardless if there is
a timeout window active or not. If false, the very last
upstream item is ignored and the flow terminates.Throttles items from the upstream |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time to wait after an item emission towards the downstream
before trying to emit the latest item from upstream again timeout, @NonNull TimeUnit the time unit unit, @NonNull Scheduler the scheduler, boolean Scheduler where the timed wait and latest item
emission will be performedIf emitLast, @NonNull Consumer<? super T> true, the very last item from the upstream will be emitted
immediately when the upstream completes, regardless if there is
a timeout window active or not. If false, the very last
upstream item is ignored and the flow terminates.called when an item is replaced by a newer item that doesn't get delivered
to the downstream, including the very last item if onDropped)emitLast is false
and the current undelivered item when the sequence gets canceled.Throttles items from the upstream |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the window of time that must pass after the emission of an item from the current
timeout, @NonNull TimeUnit Flowable in which it emits no items in order for the item to be emitted by the
resulting Flowablethe unit of time for the specified unit)timeoutReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the window of time that must pass after the emission of an item from the current
timeout, @NonNull TimeUnit Flowable in which it emits no items in order for the item to be emitted by the
resulting Flowablethe unit of time for the specified unit, @NonNull Scheduler timeoutthe scheduler)Scheduler to use internally to manage the timers that handle the timeout for each
itemReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe length of the window of time that must pass after the emission of an item from the current
timeout, @NonNull TimeUnit Flowable in which it emits no items in order for the item to be emitted by the
resulting Flowablethe unit of time for the specified unit, @NonNull Scheduler timeoutthe scheduler, @NonNull Consumer<? super T> Scheduler to use internally to manage the timers that handle the timeout for each
itemcalled with the current entry when it has been replaced by a new one onDropped)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instanceReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler)Scheduler used to compute time intervalsReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time unit for the current time unit)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time unit for the current time unit, @NonNull Scheduler the scheduler)Scheduler used to compute time intervalsReturns a |
| public final < the timeout value type (ignored) V> @NonNull Flowable | Returns: the newFlowable instancea function that returns a itemTimeoutIndicator)Publisher for each item emitted by the current
Flowable and that determines the timeout window for the subsequent itemReturns a |
| public final < the timeout value type (ignored) V> @NonNull Flowable | Returns: the newFlowable instancea function that returns a itemTimeoutIndicator, @NonNull Publisher<? extends T> Publisher, for each item emitted by the current Flowable, that
determines the timeout window for the subsequent itemthe fallback fallback)Publisher to switch to if the current Flowable times outReturns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancemaximum duration between items before a timeout occurs timeout, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Publisher<? extends T> timeout argumentthe fallback fallback)Publisher to use in case of a timeoutReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancemaximum duration between items before a timeout occurs timeout, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Scheduler timeout argumentthe scheduler, @NonNull Publisher<? extends T> Scheduler to run the timeout timers onthe fallback)Publisher to use as the fallback in case of a timeoutReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancemaximum duration between items before a timeout occurs timeout, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Scheduler timeout argumentthe scheduler)Scheduler to run the timeout timers onReturns a |
| public final < the first timeout value type (ignored) U, the subsequent timeout value type (ignored) V> @NonNull Flowable | Returns: the newFlowable instancea function that returns a firstTimeoutIndicator, @NonNull Function<? super T, @NonNull ? extends Publisher<V>> Publisher that determines the timeout window for the first source
itema function that returns a itemTimeoutIndicator)Publisher for each item emitted by the current Flowable and that
determines the timeout window in which the subsequent source item must arrive in order to
continue the sequenceReturns a |
| public final < the first timeout value type (ignored) U, the subsequent timeout value type (ignored) V> @NonNull Flowable | Returns: the newFlowable instancea function that returns a firstTimeoutIndicator, @NonNull Function<? super T, @NonNull ? extends Publisher<V>> Publisher which determines the timeout window for the first source
itema function that returns a itemTimeoutIndicator, @NonNull Publisher<? extends T> Publisher for each item emitted by the current Flowable and that
determines the timeout window in which the subsequent source item must arrive in order to
continue the sequencethe fallback fallback)Publisher to switch to if the current Flowable times outReturns a |
| private Flowable | |
| private <U, V> Flowable | |
| public static @NonNull Flowable | |
| public static @NonNull Flowable | Returns: the newFlowable instancethe initial delay before emitting a single 0L delay, @NonNull TimeUnit time units to use for unit, @NonNull Scheduler delaythe scheduler)Scheduler to use for scheduling the itemReturns a |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | |
| public final @NonNull Flowable | Returns: the newFlowable instancethe time unit for the current time unit, @NonNull Scheduler the scheduler)Scheduler to use as a time sourceReturns a |
| public final < the resulting object type R> R | Returns: the converted valuethe function that receives the current converter)Flowable instance and returns a valueCalls the specified converter function during assembly time and returns its resulting value. |
| public final @NonNull Future | |
| public final @NonNull Single | |
| public final @NonNull Single | |
| public final < the subclass of a collection of Ts U extends Collection | |
| public final < the key type of the Map K> @NonNull Single | Returns: the newSingle instancethe function that extracts the key from a source item to be used in the keySelector)HashMapReturns a |
| public final < the key type of the Map K, the value type of the Map V> @NonNull Single | Returns: the newSingle instancethe function that extracts the key from a source item to be used in the keySelector, @NonNull Function<? super T, ? extends V> HashMapthe function that extracts the value from a source item to be used in the valueSelector)HashMapReturns a |
| public final < the key type of the Map K, the value type of the Map V> @NonNull Single | Returns: the newSingle instancethe function that extracts the key from a source item to be used in the Map keySelector, @NonNull Function<? super T, ? extends V> the function that extracts the value from the source items to be used as value in the Map valueSelector, @NonNull Supplier<? extends Map<K, V>> the function that returns a mapSupplier)Map instance to be usedReturns a |
| public final < the key type of the Map K> @NonNull Single | Returns: the newSingle instancethe function that extracts the key from the source items to be used as key in the keySelector)HashMapReturns a |
| public final < the key type of the Map K, the value type of the Map V> @NonNull Single | Returns: the newSingle instancethe function that extracts a key from the source items to be used as key in the keySelector, @NonNull Function<? super T, ? extends V> HashMapthe function that extracts a value from the source items to be used as value in the valueSelector)HashMapReturns a |
| public final < the key type of the Map K, the value type of the Map V> @NonNull Single | Returns: the newSingle instancethe function that extracts a key from the source items to be used as the key in the Map keySelector, @NonNull Function<? super T, ? extends V> the function that extracts a value from the source items to be used as the value in the valueSelector, @NonNull Supplier<? extends Map<K, Collection<V>>> Mapthe function that returns a Map instance to be used mapSupplier, @NonNull Function<? super K, ? extends Collection<? super V>> the function that returns a collectionFactory)Collection instance for a particular key to be used in the MapReturns a |
| public final < the key type of the K, Mapthe value type of the V> @NonNull SingleMap | Returns: the newSingle instancethe function that extracts a key from the source items to be used as the key in the keySelector, @NonNull Function<? super T, ? extends V> Mapthe function that extracts a value from the source items to be used as the value in the valueSelector, @NonNull Supplier<Map<K, Collection<V>>> Mapthe function that returns a mapSupplier)Map instance to be usedReturns a |
| public final @NonNull Observable | Returns: the newObservable instanceConverts the current |
| public final @NonNull Single | Returns: the newSingle instanceReturns a |
| public final @NonNull Single | Returns: the newSingle instancea function that compares two items emitted by the current comparator)Flowable and returns an int
that indicates their sort orderReturns a |
| public final @NonNull Single | Returns: the newSingle instancea function that compares two items emitted by the current comparator, int Flowable and returns an int
that indicates their sort orderthe initial capacity of the capacityHint)ArrayList used to accumulate items before sortingReturns a |
| public final @NonNull Single | Returns: the newSingle instancethe initial capacity of the capacityHint)ArrayList used to accumulate items before sortingReturns a |
| public static < the value type emitted T> @NonNull Flowable | Returns: the newFlowable instancethe onSubscribe)Publisher instance to wrapCreate a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe scheduler)Scheduler to perform cancellation actions onCancels the current |
| public static < the element type of the generated T, Publisherthe type of the resource associated with the output sequence D> @NonNull Flowable | Returns: the newFlowable instancethe factory function to create a resource object that depends on the resourceSupplier, @NonNull Function<? super D, @NonNull ? extends Publisher<? extends T>> Publisherthe factory function to create a sourceSupplier, @NonNull Consumer<? super D> Publisherthe function that will dispose of the resource resourceCleanup)Constructs a |
| public static < the element type of the generated T, Publisherthe type of the resource associated with the output sequence D> @NonNull Flowable | Returns: the newFlowable instancethe factory function to create a resource object that depends on the resourceSupplier, @NonNull Function<? super D, @NonNull ? extends Publisher<? extends T>> Publisherthe factory function to create a sourceSupplier, @NonNull Consumer<? super D> Publisherthe function that will dispose of the resource resourceCleanup, boolean If eager)true, the resource disposal will happen either on a cancel() call before the upstream is disposed
or just before the emission of a terminal event (onComplete or onError).
If false the resource disposal will happen either on a cancel() call after the upstream is disposed
or just after the emission of a terminal event (onComplete or onError).Constructs a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum size of each window before it should be emitted count)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum size of each window before it should be emitted count, long how many items need to be skipped before starting a new window. Note that if skip)skip and
count are equal this is the same operation as window(long).Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe maximum size of each window before it should be emitted count, long how many items need to be skipped before starting a new window. Note that if skip, int skip and
count are equal this is the same operation as window(long).the capacity hint for the buffer in the inner windows bufferSize)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted timespan, long the period of time after which a new window will be created timeskip, @NonNull TimeUnit the unit of time that applies to the unit)timespan and timeskip argumentsReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted timespan, long the period of time after which a new window will be created timeskip, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Scheduler timespan and timeskip argumentsthe scheduler)Scheduler to use when determining the end and start of a windowReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted timespan, long the period of time after which a new window will be created timeskip, @NonNull TimeUnit the unit of time that applies to the unit, @NonNull Scheduler timespan and timeskip argumentsthe scheduler, int Scheduler to use when determining the end and start of a windowthe capacity hint for the buffer in the inner windows bufferSize)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time that applies to the unit)timespan argumentReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time that applies to the unit, long timespan argumentthe maximum size of each window before it should be emitted count)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time that applies to the unit, long timespan argumentthe maximum size of each window before it should be emitted count, boolean if restart)true, when a window reaches the capacity limit, the timer is restarted as wellReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler)Scheduler to use when determining the end and start of a windowReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler, long Scheduler to use when determining the end and start of a windowthe maximum size of each window before it should be emitted count)Returns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler, long Scheduler to use when determining the end and start of a windowthe maximum size of each window before it should be emitted count, boolean if restart)true, when a window reaches the capacity limit, the timer is restarted as wellReturns a |
| public final @NonNull Flowable | Returns: the newFlowable instancethe period of time each window collects items before it should be emitted and replaced with a
new window timespan, @NonNull TimeUnit the unit of time which applies to the unit, @NonNull Scheduler timespan argumentthe scheduler, long Scheduler to use when determining the end and start of a windowthe maximum size of each window before it should be emitted count, boolean if restart, int true, when a window reaches the capacity limit, the timer is restarted as wellthe capacity hint for the buffer in the inner windows bufferSize)Returns a |
| public final < the window element type (ignored) B> @NonNull Flowable | Returns: the newFlowable instancea boundaryIndicator)Publisher whose emitted items close and open windowsReturns a |
| public final < the window element type (ignored) B> @NonNull Flowable | Returns: the newFlowable instancea boundaryIndicator, int Publisher whose emitted items close and open windowsthe capacity hint for the buffer in the inner windows bufferSize)Returns a |
| public final < the element type of the window-opening U, Publisherthe element type of the window-closing V> @NonNull FlowablePublishers | Returns: the newFlowable instancea openingIndicator, @NonNull Function<? super U, @NonNull ? extends Publisher<V>> Publisher that, when it emits an item, causes another window to be createda closingIndicator)Function that produces a Publisher for every window created. When this Publisher
emits an item, the associated window is closed and emittedReturns a |
| public final < the element type of the window-opening U, Publisherthe element type of the window-closing V> @NonNull FlowablePublishers | Returns: the newFlowable instancea openingIndicator, @NonNull Function<? super U, @NonNull ? extends Publisher<V>> Publisher that, when it emits an item, causes another window to be createda closingIndicator, int Function that produces a Publisher for every window created. When this Publisher
emits an item, the associated window is closed and emittedthe capacity hint for the buffer in the inner windows bufferSize)Returns a |
| public final < the element type of the other U, Publisherthe result type of the combination R> @NonNull Flowable | Returns: the newFlowable instancethe other other, @NonNull BiFunction<? super T, ? super U, ? extends R> Publisherthe function to call when the current combiner)Flowable emits an item and the other Publisher has already
emitted an item, to generate the item to be emitted by the resulting FlowableMerges the specified |
| public final < the first other source's value type T1, the second other source's value type T2, the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe first other source1, @NonNull Publisher<T2> Publisherthe second other source2, @NonNull Function3<? super T, ? super T1, ? super T2, R> Publisherthe function called with an array of values from each participating combiner)PublisherCombines the value emission from the current |
| public final < the first other source's value type T1, the second other source's value type T2, the third other source's value type T3, the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe first other source1, @NonNull Publisher<T2> Publisherthe second other source2, @NonNull Publisher<T3> Publisherthe third other source3, @NonNull Function4<? super T, ? super T1, ? super T2, ? super T3, R> Publisherthe function called with an array of values from each participating combiner)PublisherCombines the value emission from the current |
| public final < the first other source's value type T1, the second other source's value type T2, the third other source's value type T3, the fourth other source's value type T4, the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe first other source1, @NonNull Publisher<T2> Publisherthe second other source2, @NonNull Publisher<T3> Publisherthe third other source3, @NonNull Publisher<T4> Publisherthe fourth other source4, @NonNull Function5<? super T, ? super T1, ? super T2, ? super T3, ? super T4, R> Publisherthe function called with an array of values from each participating combiner)PublisherCombines the value emission from the current |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe array of other sources others, @NonNull Function<? super Object[], R> the function called with an array of values from each participating combiner)PublisherCombines the value emission from the current |
| public final < the result value type R> @NonNull Flowable | Returns: the newFlowable instancethe iterable of other sources others, @NonNull Function<? super Object[], R> the function called with an array of values from each participating combiner)PublisherCombines the value emission from the current |
| public static < the common value type T, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancean sources, @NonNull Function<? super Object[], ? extends R> Iterable of source Publishersa function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the common source value type T, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancean sources, @NonNull Function<? super Object[], ? extends R> Iterable of source Publishersa function that, when applied to an item emitted by each of the source zipper, boolean Publishers, results in
an item that will be emitted by the resulting Flowabledelay errors signaled by any of the source delayError, int Publisher until all Publishers terminatethe number of elements to prefetch from each source bufferSize)PublisherReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull BiFunction<? super T1, ? super T2, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results
in an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull BiFunction<? super T1, ? super T2, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper, boolean Publishers, results
in an item that will be emitted by the resulting Flowabledelay errors from any of the source delayError)Publishers till the other terminatesReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull BiFunction<? super T1, ? super T2, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper, boolean Publishers, results
in an item that will be emitted by the resulting Flowabledelay errors from any of the source delayError, int Publishers till the other terminatesthe number of elements to prefetch from each source bufferSize)PublisherReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Function3<? super T1, ? super T2, ? super T3, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the value type of the fourth source T4, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Publisher<? extends T4> Publishera fourth source source4, @NonNull Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the value type of the fourth source T4, the value type of the fifth source T5, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Publisher<? extends T4> Publishera fourth source source4, @NonNull Publisher<? extends T5> Publishera fifth source source5, @NonNull Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the value type of the fourth source T4, the value type of the fifth source T5, the value type of the sixth source T6, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Publisher<? extends T4> Publishera fourth source source4, @NonNull Publisher<? extends T5> Publishera fifth source source5, @NonNull Publisher<? extends T6> Publishera sixth source source6, @NonNull Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the value type of the fourth source T4, the value type of the fifth source T5, the value type of the sixth source T6, the value type of the seventh source T7, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Publisher<? extends T4> Publishera fourth source source4, @NonNull Publisher<? extends T5> Publishera fifth source source5, @NonNull Publisher<? extends T6> Publishera sixth source source6, @NonNull Publisher<? extends T7> Publishera seventh source source7, @NonNull Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the value type of the fourth source T4, the value type of the fifth source T5, the value type of the sixth source T6, the value type of the seventh source T7, the value type of the eighth source T8, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Publisher<? extends T4> Publishera fourth source source4, @NonNull Publisher<? extends T5> Publishera fifth source source5, @NonNull Publisher<? extends T6> Publishera sixth source source6, @NonNull Publisher<? extends T7> Publishera seventh source source7, @NonNull Publisher<? extends T8> Publisheran eighth source source8, @NonNull Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the value type of the first source T1, the value type of the second source T2, the value type of the third source T3, the value type of the fourth source T4, the value type of the fifth source T5, the value type of the sixth source T6, the value type of the seventh source T7, the value type of the eighth source T8, the value type of the ninth source T9, the zipped result type R> @NonNull Flowable | Returns: the newFlowable instancethe first source source1, @NonNull Publisher<? extends T2> Publishera second source source2, @NonNull Publisher<? extends T3> Publishera third source source3, @NonNull Publisher<? extends T4> Publishera fourth source source4, @NonNull Publisher<? extends T5> Publishera fifth source source5, @NonNull Publisher<? extends T6> Publishera sixth source source6, @NonNull Publisher<? extends T7> Publishera seventh source source7, @NonNull Publisher<? extends T8> Publisheran eighth source source8, @NonNull Publisher<? extends T9> Publishera ninth source source9, @NonNull Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends R> Publishera function that, when applied to an item emitted by each of the source zipper)Publishers, results in
an item that will be emitted by the resulting FlowableReturns a |
| public static < the common element type T, the result type R> @NonNull Flowable | Returns: the newFlowable instancea function that, when applied to an item emitted by each of the source zipper, boolean Publishers, results in
an item that will be emitted by the resulting Flowabledelay errors signaled by any of the source delayError, int Publisher until all Publishers terminatethe number of elements to prefetch from each source bufferSize, @NonNull Publisher<? extends T>... Publisheran array of source sources)PublishersReturns a |
| public final < the type of items in the U, other Iterablethe type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe other, @NonNull BiFunction<? super T, ? super U, ? extends R> Iterable sequencea function that combines the pairs of items from the current zipper)Flowable and the Iterable to generate
the items to be emitted by the resulting FlowableReturns a |
| public final < the type of items emitted by the U, other Publisherthe type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe other other, @NonNull BiFunction<? super T, ? super U, ? extends R> Publishera function that combines the pairs of items from the two zipper)Publishers to generate the items to
be emitted by the resulting FlowableReturns a |
| public final < the type of items emitted by the U, other Publisherthe type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe other other, @NonNull BiFunction<? super T, ? super U, ? extends R> Publishera function that combines the pairs of items from the two zipper, boolean Publishers to generate the items to
be emitted by the resulting Flowableif delayError)true, errors from the current Flowable or the other Publisher is delayed until both terminateReturns a |
| public final < the type of items emitted by the U, other Publisherthe type of items emitted by the resulting R> @NonNull FlowableFlowable | Returns: the newFlowable instancethe other other, @NonNull BiFunction<? super T, ? super U, ? extends R> Publishera function that combines the pairs of items from the two zipper, boolean Publishers to generate the items to
be emitted by the resulting Flowableif delayError, int true, errors from the current Flowable or the other Publisher is delayed until both terminatethe capacity hint for the buffer in the inner windows bufferSize)Returns a |