io.reactivex.rxjava3.parallel

Class ParallelFlowable<T>

java.lang.Object

io.reactivex.rxjava3.parallel.ParallelFlowable<T>

Type Parameters:

T - the value type

public abstract class ParallelFlowable<T>
extends Object

Abstract base class for parallel publishing of events signaled to an array of Subscribers.

Use from(Publisher) to start processing a regular Publisher in 'rails'. Use runOn(Scheduler) to introduce where each 'rail' should run on thread-vise. Use sequential() to merge the sources back into a single Flowable.

History: 2.0.5 - experimental; 2.1 - beta

Since:

2.2

Constructor Summary

Constructors

Constructor and Description
ParallelFlowable()

Method Summary

Modifier and Type	Method and Description
<A,R> @NonNull Flowable<R>	collect(@NonNull Collector<T,A,R> collector) Reduces all values within a 'rail' and across 'rails' with a callbacks of the given Collector into one Flowable containing a single value.
<C> @NonNull ParallelFlowable<C>	collect(@NonNull Supplier<? extends C> collectionSupplier, @NonNull BiConsumer<? super C,? super T> collector) Collect the elements in each rail into a collection supplied via a collectionSupplier and collected into with a collector action, emitting the collection at the end.
<U> @NonNull ParallelFlowable<U>	compose(@NonNull ParallelTransformer<T,U> composer) Allows composing operators, in assembly time, on top of this ParallelFlowable and returns another ParallelFlowable with composed features.
<R> @NonNull ParallelFlowable<R>	concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper) Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.
<R> @NonNull ParallelFlowable<R>	concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int prefetch) Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.
<R> @NonNull ParallelFlowable<R>	concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean tillTheEnd) Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.
<R> @NonNull ParallelFlowable<R>	concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, int prefetch, boolean tillTheEnd) Generates and concatenates Publishers on each 'rail', optionally delaying errors and using the given prefetch amount for generating Publishers upfront.
@NonNull ParallelFlowable<T>	doAfterNext(@NonNull Consumer<? super T> onAfterNext) Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.
@NonNull ParallelFlowable<T>	doAfterTerminated(@NonNull Action onAfterTerminate) Run the specified Action when a 'rail' completes or signals an error.
@NonNull ParallelFlowable<T>	doOnCancel(@NonNull Action onCancel) Run the specified Action when a 'rail' receives a cancellation.
@NonNull ParallelFlowable<T>	doOnComplete(@NonNull Action onComplete) Run the specified Action when a 'rail' completes.
@NonNull ParallelFlowable<T>	doOnError(@NonNull Consumer<? super Throwable> onError) Call the specified consumer with the exception passing through any 'rail'.
@NonNull ParallelFlowable<T>	doOnNext(@NonNull Consumer<? super T> onNext) Call the specified consumer with the current element passing through any 'rail'.
@NonNull ParallelFlowable<T>	doOnNext(@NonNull Consumer<? super T> onNext, @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.
@NonNull ParallelFlowable<T>	doOnNext(@NonNull Consumer<? super T> onNext, @NonNull ParallelFailureHandling errorHandler) Call the specified consumer with the current element passing through any 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.
@NonNull ParallelFlowable<T>	doOnRequest(@NonNull LongConsumer onRequest) Call the specified consumer with the request amount if any rail receives a request.
@NonNull ParallelFlowable<T>	doOnSubscribe(@NonNull Consumer<? super Subscription> onSubscribe) Call the specified callback when a 'rail' receives a Subscription from its upstream.
@NonNull ParallelFlowable<T>	filter(@NonNull Predicate<? super T> predicate) Filters the source values on each 'rail'.
@NonNull ParallelFlowable<T>	filter(@NonNull Predicate<? super T> predicate, @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler) Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.
@NonNull ParallelFlowable<T>	filter(@NonNull Predicate<? super T> predicate, @NonNull ParallelFailureHandling errorHandler) Filters the source values on each 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.
<R> @NonNull ParallelFlowable<R>	flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper) Generates and flattens Publishers on each 'rail'.
<R> @NonNull ParallelFlowable<R>	flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayError) Generates and flattens Publishers on each 'rail', optionally delaying errors.
<R> @NonNull ParallelFlowable<R>	flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayError, int maxConcurrency) Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.
<R> @NonNull ParallelFlowable<R>	flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper, boolean delayError, int maxConcurrency, int prefetch) Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.
<U> @NonNull ParallelFlowable<U>	flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper) Returns a ParallelFlowable that merges each item emitted by the source on each rail with the values in an Iterable corresponding to that item that is generated by a selector.
<U> @NonNull ParallelFlowable<U>	flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper, int bufferSize) Returns a ParallelFlowable that merges each item emitted by the source ParallelFlowable with the values in an Iterable corresponding to that item that is generated by a selector.
<R> @NonNull ParallelFlowable<R>	flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper) Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.
<R> @NonNull ParallelFlowable<R>	flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper, int prefetch) Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.
static <T> @NonNull ParallelFlowable<T>	from(@NonNull Publisher<? extends T> source) Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.
static <T> @NonNull ParallelFlowable<T>	from(@NonNull Publisher<? extends T> source, int parallelism) Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.
static <T> @NonNull ParallelFlowable<T>	from(@NonNull Publisher<? extends T> source, int parallelism, int prefetch) Take a Publisher and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.
static <T> @NonNull ParallelFlowable<T>	fromArray(Publisher<T>... publishers) Wraps multiple Publishers into a ParallelFlowable which runs them in parallel and unordered.
<R> @NonNull ParallelFlowable<R>	map(@NonNull Function<? super T,? extends R> mapper) Maps the source values on each 'rail' to another value.
<R> @NonNull ParallelFlowable<R>	map(@NonNull Function<? super T,? extends R> mapper, @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.
<R> @NonNull ParallelFlowable<R>	map(@NonNull Function<? super T,? extends R> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to another value and handles errors based on the given ParallelFailureHandling enumeration value.
<R> @NonNull ParallelFlowable<R>	mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper) Maps the source values on each 'rail' to an optional and emits its value if any.
<R> @NonNull ParallelFlowable<R>	mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper, @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.
<R> @NonNull ParallelFlowable<R>	mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper, @NonNull ParallelFailureHandling errorHandler) Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the given ParallelFailureHandling enumeration value.
abstract int	parallelism() Returns the number of expected parallel Subscribers.
@NonNull Flowable<T>	reduce(@NonNull BiFunction<T,T,T> reducer) Reduces all values within a 'rail' and across 'rails' with a reducer function into one Flowable sequence.
<R> @NonNull ParallelFlowable<R>	reduce(@NonNull Supplier<R> initialSupplier, @NonNull BiFunction<R,? super T,R> reducer) Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.
@NonNull ParallelFlowable<T>	runOn(@NonNull Scheduler scheduler) Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with no work-stealing and default prefetch amount.
@NonNull ParallelFlowable<T>	runOn(@NonNull Scheduler scheduler, int prefetch) Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with possibly work-stealing and a given prefetch amount.
@NonNull Flowable<T>	sequential() Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails.
@NonNull Flowable<T>	sequential(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails.
@NonNull Flowable<T>	sequentialDelayError() Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.
@NonNull Flowable<T>	sequentialDelayError(int prefetch) Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.
@NonNull Flowable<T>	sorted(@NonNull Comparator<? super T> comparator) Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.
@NonNull Flowable<T>	sorted(@NonNull Comparator<? super T> comparator, int capacityHint) Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.
abstract void	subscribe(@NonNull Subscriber<? super T>[] subscribers) Subscribes an array of Subscribers to this ParallelFlowable and triggers the execution chain for all 'rails'.
<R> R	to(@NonNull ParallelFlowableConverter<T,R> converter) Calls the specified converter function during assembly time and returns its resulting value.
@NonNull Flowable<List<T>>	toSortedList(@NonNull Comparator<? super T> comparator) Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.
@NonNull Flowable<List<T>>	toSortedList(@NonNull Comparator<? super T> comparator, int capacityHint) Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.
protected boolean	validate(@NonNull Subscriber<?>[] subscribers) Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlowable.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ParallelFlowable

public ParallelFlowable()

Method Detail

subscribe

@BackpressureSupport(value=SPECIAL)
 @SchedulerSupport(value="none")
public abstract void subscribe(@NonNull Subscriber<? super T>[] subscribers)

Subscribes an array of Subscribers to this ParallelFlowable and triggers the execution chain for all 'rails'.

Backpressure:

The backpressure behavior/expectation is determined by the supplied Subscriber.

Scheduler:

subscribe does not operate by default on a particular Scheduler.

Parameters:

subscribers - the subscribers array to run in parallel, the number of items must be equal to the parallelism level of this ParallelFlowable

Throws:

NullPointerException - if subscribers is null

See Also:

parallelism()

parallelism

@CheckReturnValue
public abstract int parallelism()

Returns the number of expected parallel Subscribers.

Returns:

the number of expected parallel Subscribers

validate

protected final boolean validate(@NonNull Subscriber<?>[] subscribers)

Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlowable.

Parameters:

subscribers - the array of Subscribers

Returns:

true if the number of subscribers equals to the parallelism level

Throws:

NullPointerException - if subscribers is null

IllegalArgumentException - if subscribers.length is different from parallelism()

from

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> @NonNull ParallelFlowable<T> from(@NonNull Publisher<? extends T> source)

Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.

Backpressure:

The operator honors the backpressure of the parallel rails and requests Flowable.bufferSize() amount from the upstream, followed by 75% of that amount requested after every 75% received.

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

source - the source Publisher

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if source is null

from

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> @NonNull ParallelFlowable<T> from(@NonNull Publisher<? extends T> source,
        int parallelism)

Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.

Backpressure:

The operator honors the backpressure of the parallel rails and requests Flowable.bufferSize() amount from the upstream, followed by 75% of that amount requested after every 75% received.

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

source - the source Publisher

parallelism - the number of parallel rails

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if source is null

IllegalArgumentException - if parallelism is non-positive

from

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=FULL)
public static <T> @NonNull ParallelFlowable<T> from(@NonNull Publisher<? extends T> source,
        int parallelism,
        int prefetch)

Take a Publisher and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.

Backpressure:

The operator honors the backpressure of the parallel rails and requests the prefetch amount from the upstream, followed by 75% of that amount requested after every 75% received.

Scheduler:

from does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

source - the source Publisher

parallelism - the number of parallel rails

prefetch - the number of values to prefetch from the source the source until there is a rail ready to process it.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if source is null

IllegalArgumentException - if parallelism or prefetch is non-positive

map

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> map(@NonNull Function<? super T,? extends R> mapper)

Maps the source values on each 'rail' to another value.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

R - the output value type

Parameters:

mapper - the mapper function turning Ts into Rs.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

map

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> map(@NonNull Function<? super T,? extends R> mapper,
        @NonNull ParallelFailureHandling errorHandler)

Maps the source values on each 'rail' to another value and handles errors based on the given ParallelFailureHandling enumeration value.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Type Parameters:

R - the output value type

Parameters:

mapper - the mapper function turning Ts into Rs.

errorHandler - the enumeration that defines how to handle errors thrown from the mapper function

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper or errorHandler is null

Since:

2.2

map

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> map(@NonNull Function<? super T,? extends R> mapper,
        @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)

Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Type Parameters:

R - the output value type

Parameters:

mapper - the mapper function turning Ts into Rs.

errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper or errorHandler is null

Since:

2.2

filter

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final @NonNull ParallelFlowable<T> filter(@NonNull Predicate<? super T> predicate)

Filters the source values on each 'rail'.

Note that the same predicate may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

filter does not operate by default on a particular Scheduler.

Parameters:

predicate - the function returning true to keep a value or false to drop a value

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if predicate is null

filter

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final @NonNull ParallelFlowable<T> filter(@NonNull Predicate<? super T> predicate,
        @NonNull ParallelFailureHandling errorHandler)

Filters the source values on each 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.

Note that the same predicate may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

filter does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Parameters:

predicate - the function returning true to keep a value or false to drop a value

errorHandler - the enumeration that defines how to handle errors thrown from the predicate

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if predicate or errorHandler is null

Since:

2.2

filter

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final @NonNull ParallelFlowable<T> filter(@NonNull Predicate<? super T> predicate,
        @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)

Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.

Note that the same predicate may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Parameters:

predicate - the function returning true to keep a value or false to drop a value

errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if predicate or errorHandler is null

Since:

2.2

runOn

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public final @NonNull ParallelFlowable<T> runOn(@NonNull Scheduler scheduler)

Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with no work-stealing and default prefetch amount.

This operator uses the default prefetch size returned by Flowable.bufferSize().

The operator will call Scheduler.createWorker() as many times as this ParallelFlowable's parallelism level is.

No assumptions are made about the Scheduler's parallelism level, if the Scheduler's parallelism level is lower than the ParallelFlowable's, some rails may end up on the same thread/worker.

This operator doesn't require the Scheduler to be trampolining as it does its own built-in trampolining logic.

Backpressure:

The operator honors the backpressure of the parallel rails and requests Flowable.bufferSize() amount from the upstream, followed by 75% of that amount requested after every 75% received.

Scheduler:

runOn drains the upstream rails on the specified Scheduler's Workers.

Parameters:

scheduler - the scheduler to use

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if scheduler is null

runOn

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="custom")
public final @NonNull ParallelFlowable<T> runOn(@NonNull Scheduler scheduler,
        int prefetch)

Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with possibly work-stealing and a given prefetch amount.

This operator uses the default prefetch size returned by Flowable.bufferSize().

The operator will call Scheduler.createWorker() as many times as this ParallelFlowable's parallelism level is.

No assumptions are made about the Scheduler's parallelism level, if the Scheduler's parallelism level is lower than the ParallelFlowable's, some rails may end up on the same thread/worker.

This operator doesn't require the Scheduler to be trampolining as it does its own built-in trampolining logic.

Backpressure:

The operator honors the backpressure of the parallel rails and requests the prefetch amount from the upstream, followed by 75% of that amount requested after every 75% received.

Scheduler:

runOn drains the upstream rails on the specified Scheduler's Workers.

Parameters:

scheduler - the scheduler to use that rail's worker has run out of work.

prefetch - the number of values to request on each 'rail' from the source

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if scheduler is null

IllegalArgumentException - if prefetch is non-positive

reduce

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final @NonNull Flowable<T> reduce(@NonNull BiFunction<T,T,T> reducer)

Reduces all values within a 'rail' and across 'rails' with a reducer function into one Flowable sequence.

Note that the same reducer function may be called from multiple threads concurrently.

Backpressure:

The operator honors backpressure from the downstream and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

reduce does not operate by default on a particular Scheduler.

Parameters:

reducer - the function to reduce two values into one.

Returns:

the new Flowable instance emitting the reduced value or empty if the current ParallelFlowable is empty

Throws:

NullPointerException - if reducer is null

reduce

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> reduce(@NonNull Supplier<R> initialSupplier,
        @NonNull BiFunction<R,? super T,R> reducer)

Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator honors backpressure from the downstream rails and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

reduce does not operate by default on a particular Scheduler.

Type Parameters:

R - the reduced output type

Parameters:

initialSupplier - the supplier for the initial value

reducer - the function to reduce a previous output of reduce (or the initial value supplied) with a current source value.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if initialSupplier or reducer is null

sequential

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull Flowable<T> sequential()

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails.

This operator uses the default prefetch size returned by Flowable.bufferSize().

Backpressure:

The operator honors backpressure from the downstream and requests Flowable.bufferSize() amount from each rail, then requests from each rail 75% of this amount after 75% received.

Scheduler:

sequential does not operate by default on a particular Scheduler.

Returns:

the new Flowable instance

See Also:

sequential(int), sequentialDelayError()

sequential

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull Flowable<T> sequential(int prefetch)

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails.

Backpressure:

The operator honors backpressure from the downstream and requests the prefetch amount from each rail, then requests from each rail 75% of this amount after 75% received.

Scheduler:

sequential does not operate by default on a particular Scheduler.

Parameters:

prefetch - the prefetch amount to use for each rail

Returns:

the new Flowable instance

Throws:

IllegalArgumentException - if prefetch is non-positive

See Also:

sequential(), sequentialDelayError(int)

sequentialDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull Flowable<T> sequentialDelayError()

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.

This operator uses the default prefetch size returned by Flowable.bufferSize().

Backpressure:

The operator honors backpressure from the downstream and requests Flowable.bufferSize() amount from each rail, then requests from each rail 75% of this amount after 75% received.

Scheduler:

sequentialDelayError does not operate by default on a particular Scheduler.

History: 2.0.7 - experimental

Returns:

the new Flowable instance

Since:

2.2

See Also:

sequentialDelayError(int), sequential()

sequentialDelayError

@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull Flowable<T> sequentialDelayError(int prefetch)

Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.

Backpressure:

The operator honors backpressure from the downstream and requests the prefetch amount from each rail, then requests from each rail 75% of this amount after 75% received.

Scheduler:

sequentialDelayError does not operate by default on a particular Scheduler.

History: 2.0.7 - experimental

Parameters:

prefetch - the prefetch amount to use for each rail

Returns:

the new Flowable instance

Throws:

IllegalArgumentException - if prefetch is non-positive

Since:

2.2

See Also:

sequential(), sequentialDelayError()

sorted

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final @NonNull Flowable<T> sorted(@NonNull Comparator<? super T> comparator)

Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.

This operator requires a finite source ParallelFlowable.

Backpressure:

The operator honors backpressure from the downstream and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

sorted does not operate by default on a particular Scheduler.

Parameters:

comparator - the comparator to use

Returns:

the new Flowable instance

Throws:

NullPointerException - if comparator is null

sorted

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final @NonNull Flowable<T> sorted(@NonNull Comparator<? super T> comparator,
        int capacityHint)

Sorts the 'rails' of this ParallelFlowable and returns a Flowable that sequentially picks the smallest next value from the rails.

This operator requires a finite source ParallelFlowable.

Backpressure:

The operator honors backpressure from the downstream and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

sorted does not operate by default on a particular Scheduler.

Parameters:

comparator - the comparator to use

capacityHint - the expected number of total elements

Returns:

the new Flowable instance

Throws:

NullPointerException - if comparator is null

IllegalArgumentException - if capacityHint is non-positive

toSortedList

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final @NonNull Flowable<List<T>> toSortedList(@NonNull Comparator<? super T> comparator)

Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.

This operator requires a finite source ParallelFlowable.

Backpressure:

The operator honors backpressure from the downstream and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

comparator - the comparator to compare elements

Returns:

the new Flowable instance

Throws:

NullPointerException - if comparator is null

toSortedList

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final @NonNull Flowable<List<T>> toSortedList(@NonNull Comparator<? super T> comparator,
        int capacityHint)

Sorts the 'rails' according to the comparator and returns a full sorted List as a Flowable.

This operator requires a finite source ParallelFlowable.

Backpressure:

The operator honors backpressure from the downstream and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

toSortedList does not operate by default on a particular Scheduler.

Parameters:

comparator - the comparator to compare elements

capacityHint - the expected number of total elements

Returns:

the new Flowable instance

Throws:

NullPointerException - if comparator is null

IllegalArgumentException - if capacityHint is non-positive

doOnNext

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnNext(@NonNull Consumer<? super T> onNext)

Call the specified consumer with the current element passing through any 'rail'.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onNext - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onNext is null

doOnNext

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnNext(@NonNull Consumer<? super T> onNext,
        @NonNull ParallelFailureHandling errorHandler)

Call the specified consumer with the current element passing through any 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Parameters:

onNext - the callback

errorHandler - the enumeration that defines how to handle errors thrown from the onNext consumer

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onNext or errorHandler is null

Since:

2.2

doOnNext

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnNext(@NonNull Consumer<? super T> onNext,
        @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)

Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Parameters:

onNext - the callback

errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onNext or errorHandler is null

Since:

2.2

doAfterNext

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doAfterNext(@NonNull Consumer<? super T> onAfterNext)

Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onAfterNext - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onAfterNext is null

doOnError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnError(@NonNull Consumer<? super Throwable> onError)

Call the specified consumer with the exception passing through any 'rail'.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onError - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onError is null

doOnComplete

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnComplete(@NonNull Action onComplete)

Run the specified Action when a 'rail' completes.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onComplete - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onComplete is null

doAfterTerminated

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doAfterTerminated(@NonNull Action onAfterTerminate)

Run the specified Action when a 'rail' completes or signals an error.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onAfterTerminate - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onAfterTerminate is null

doOnSubscribe

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnSubscribe(@NonNull Consumer<? super Subscription> onSubscribe)

Call the specified callback when a 'rail' receives a Subscription from its upstream.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onSubscribe - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onSubscribe is null

doOnRequest

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final @NonNull ParallelFlowable<T> doOnRequest(@NonNull LongConsumer onRequest)

Call the specified consumer with the request amount if any rail receives a request.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onRequest - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onRequest is null

doOnCancel

@BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final @NonNull ParallelFlowable<T> doOnCancel(@NonNull Action onCancel)

Run the specified Action when a 'rail' receives a cancellation.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Parameters:

onCancel - the callback

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if onCancel is null

collect

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final <C> @NonNull ParallelFlowable<C> collect(@NonNull Supplier<? extends C> collectionSupplier,
        @NonNull BiConsumer<? super C,? super T> collector)

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

Backpressure:

The operator honors backpressure from the downstream rails and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

C - the collection type

Parameters:

collectionSupplier - the supplier of the collection in each rail

collector - the collector, taking the per-rail collection and the current item

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if collectionSupplier or collector is null

fromArray

@CheckReturnValue
 @NonNull
 @SafeVarargs
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public static <T> @NonNull ParallelFlowable<T> fromArray(@NonNull Publisher<T>... publishers)

Wraps multiple Publishers into a ParallelFlowable which runs them in parallel and unordered.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

T - the value type

Parameters:

publishers - the array of publishers

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if publishers is null

IllegalArgumentException - if publishers is an empty array

to

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final <R> R to(@NonNull ParallelFlowableConverter<T,R> converter)

Calls the specified converter function during assembly time and returns its resulting value.

This allows fluent conversion to any other type.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by how the converter function composes over the upstream source.

Scheduler:

to does not operate by default on a particular Scheduler.

History: 2.1.7 - experimental

Type Parameters:

R - the resulting object type

Parameters:

converter - the function that receives the current ParallelFlowable instance and returns a value

Returns:

the converted value

Throws:

NullPointerException - if converter is null

Since:

2.2

compose

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=PASS_THROUGH)
 @SchedulerSupport(value="none")
public final <U> @NonNull ParallelFlowable<U> compose(@NonNull ParallelTransformer<T,U> composer)

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

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by how the converter function composes over the upstream source.

Scheduler:

compose does not operate by default on a particular Scheduler.

Type Parameters:

U - the output value type

Parameters:

composer - the composer function from ParallelFlowable (this) to another ParallelFlowable

Returns:

the ParallelFlowable returned by the function

Throws:

NullPointerException - if composer is null

flatMap

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

Generates and flattens Publishers on each 'rail'.

The errors are not delayed and uses unbounded concurrency along with default inner prefetch.

Backpressure:

The operator honors backpressure from the downstream rails and requests Flowable.bufferSize() amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested Flowable.bufferSize() amount upfront, then 75% of this amount requested after 75% received.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

flatMap

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
        boolean delayError)

Generates and flattens Publishers on each 'rail', optionally delaying errors.

It uses unbounded concurrency along with default inner prefetch.

Backpressure:

The operator honors backpressure from the downstream rails and requests Flowable.bufferSize() amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested Flowable.bufferSize() amount upfront, then 75% of this amount requested after 75% received.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

delayError - should the errors from the main and the inner sources delayed till everybody terminates?

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

flatMap

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
        boolean delayError,
        int maxConcurrency)

Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.

It uses a default inner prefetch.

Backpressure:

The operator honors backpressure from the downstream rails and requests maxConcurrency amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested Flowable.bufferSize() amount upfront, then 75% of this amount requested after 75% received.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

delayError - should the errors from the main and the inner sources delayed till everybody terminates?

maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency is non-positive

flatMap

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> flatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
        boolean delayError,
        int maxConcurrency,
        int prefetch)

Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.

Backpressure:

The operator honors backpressure from the downstream rails and requests maxConcurrency amount from each rail upfront and keeps requesting as many items per rail as many inner sources on that rail completed. The inner sources are requested the prefetch amount upfront, then 75% of this amount requested after 75% received.

Scheduler:

flatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

delayError - should the errors from the main and the inner sources delayed till everybody terminates?

maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers

prefetch - the number of items to prefetch from each inner Publisher

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if maxConcurrency or prefetch is non-positive

concatMap

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper)

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

Backpressure:

The operator honors backpressure from the downstream rails and requests 2 from each rail upfront and keeps requesting 1 when the inner source complete. Requests for the inner sources are determined by the downstream rails' backpressure behavior.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher source and the inner Publishers (immediate, boundary, end)

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

concatMap

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMap(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
        int prefetch)

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

Backpressure:

The operator honors backpressure from the downstream rails and requests the prefetch amount from each rail upfront and keeps requesting 75% of this amount after 75% received and the inner sources completed. Requests for the inner sources are determined by the downstream rails' backpressure behavior.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

prefetch - the number of items to prefetch from each inner Publisher source and the inner Publishers (immediate, boundary, end)

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if prefetch is non-positive

concatMapDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
        boolean tillTheEnd)

Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.

Backpressure:

The operator honors backpressure from the downstream rails and requests 2 from each rail upfront and keeps requesting 1 when the inner source complete. Requests for the inner sources are determined by the downstream rails' backpressure behavior.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

tillTheEnd - if true, all errors from the upstream and inner Publishers are delayed till all of them terminate, if false, the error is emitted when an inner Publisher terminates. source and the inner Publishers (immediate, boundary, end)

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

concatMapDelayError

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <R> @NonNull ParallelFlowable<R> concatMapDelayError(@NonNull Function<? super T,? extends Publisher<? extends R>> mapper,
        int prefetch,
        boolean tillTheEnd)

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

Backpressure:

The operator honors backpressure from the downstream rails and requests the prefetch amount from each rail upfront and keeps requesting 75% of this amount after 75% received and the inner sources completed. Requests for the inner sources are determined by the downstream rails' backpressure behavior.

Scheduler:

concatMap does not operate by default on a particular Scheduler.

Type Parameters:

R - the result type

Parameters:

mapper - the function to map each rail's value into a Publisher

prefetch - the number of items to prefetch from each inner Publisher

tillTheEnd - if true, all errors from the upstream and inner Publishers are delayed till all of them terminate, if false, the error is emitted when an inner Publisher terminates.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if prefetch is non-positive

flatMapIterable

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @NonNull
public final <U> @NonNull ParallelFlowable<U> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper)

Returns a ParallelFlowable that merges each item emitted by the source on each rail with the values in an Iterable corresponding to that item that is generated by a selector.

Backpressure:

The operator honors backpressure from each downstream rail. The source ParallelFlowables is expected to honor backpressure as well. If the source ParallelFlowable violates the rule, the operator will signal a MissingBackpressureException.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of item emitted by the resulting Iterable

Parameters:

mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source ParallelFlowable

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap, flatMapStream(Function)

flatMapIterable

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
public final <U> @NonNull ParallelFlowable<U> flatMapIterable(@NonNull Function<? super T,? extends Iterable<? extends U>> mapper,
        int bufferSize)

Returns a ParallelFlowable that merges each item emitted by the source ParallelFlowable with the values in an Iterable corresponding to that item that is generated by a selector.

Backpressure:

The operator honors backpressure from each downstream rail. The source ParallelFlowables is expected to honor backpressure as well. If the source ParallelFlowable violates the rule, the operator will signal a MissingBackpressureException.

Scheduler:

flatMapIterable does not operate by default on a particular Scheduler.

Type Parameters:

U - the type of item emitted by the resulting Iterable

Parameters:

mapper - a function that returns an Iterable sequence of values for when given an item emitted by the source ParallelFlowable

bufferSize - the number of elements to prefetch from each upstream rail

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if bufferSize is non-positive

Since:

3.0.0

See Also:

ReactiveX operators documentation: FlatMap, flatMapStream(Function, int)

mapOptional

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper)

Maps the source values on each 'rail' to an optional and emits its value if any.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

Type Parameters:

R - the output value type

Parameters:

mapper - the mapper function turning Ts into optional of Rs.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

mapOptional

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper,
        @NonNull ParallelFailureHandling errorHandler)

Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the given ParallelFailureHandling enumeration value.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Type Parameters:

R - the output value type

Parameters:

mapper - the mapper function turning Ts into optional of Rs.

errorHandler - the enumeration that defines how to handle errors thrown from the mapper function

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper or errorHandler is null

Since:

3.0.0

mapOptional

@CheckReturnValue
 @NonNull
 @SchedulerSupport(value="none")
 @BackpressureSupport(value=PASS_THROUGH)
public final <R> @NonNull ParallelFlowable<R> mapOptional(@NonNull Function<? super T,Optional<? extends R>> mapper,
        @NonNull BiFunction<? super Long,? super Throwable,ParallelFailureHandling> errorHandler)

Maps the source values on each 'rail' to an optional and emits its value if any and handles errors based on the returned value by the handler function.

Note that the same mapper function may be called from multiple threads concurrently.

Backpressure:

The operator is a pass-through for backpressure and the behavior is determined by the upstream and downstream rail behaviors.

Scheduler:

map does not operate by default on a particular Scheduler.

History: 2.0.8 - experimental

Type Parameters:

R - the output value type

Parameters:

mapper - the mapper function turning Ts into optional of Rs.

errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper or errorHandler is null

Since:

3.0.0

flatMapStream

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull ParallelFlowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper)

Maps each upstream item on each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.

Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and concatMapStream are identical operators and are provided as aliases.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function):

 source.flatMapIterable(v -> createStream(v)::iterator);
 

Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed());
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Backpressure:

The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator prefetches Flowable.bufferSize() items of the upstream (then 75% of it after the 75% received) and caches them until they are ready to be mapped into Streams after the current Stream has been consumed.

Scheduler:

flatMapStream does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the Streams and the result

Parameters:

mapper - the function that receives an upstream item and should return a Stream whose elements will be emitted to the downstream

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

Since:

3.0.0

See Also:

flatMap(Function), flatMapIterable(Function), flatMapStream(Function, int)

flatMapStream

@CheckReturnValue
 @BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @NonNull
public final <R> @NonNull ParallelFlowable<R> flatMapStream(@NonNull Function<? super T,? extends Stream<? extends R>> mapper,
        int prefetch)

Maps each upstream item of each rail into a Stream and emits the Stream's items to the downstream in a sequential fashion.

Due to the blocking and sequential nature of Java Streams, the streams are mapped and consumed in a sequential fashion without interleaving (unlike a more general flatMap(Function)). Therefore, flatMapStream and concatMapStream are identical operators and are provided as aliases.

The operator closes the Stream upon cancellation and when it terminates. The exceptions raised when closing a Stream are routed to the global error handler (RxJavaPlugins.onError(Throwable). If a Stream should not be closed, turn it into an Iterable and use flatMapIterable(Function, int):

 source.flatMapIterable(v -> createStream(v)::iterator, 32);
 

Note that Streams can be consumed only once; any subsequent attempt to consume a Stream will result in an IllegalStateException.

Primitive streams are not supported and items have to be boxed manually (e.g., via IntStream.boxed()):

 source.flatMapStream(v -> IntStream.rangeClosed(v + 1, v + 10).boxed(), 32);
 

Stream does not support concurrent usage so creating and/or consuming the same instance multiple times from multiple threads can lead to undefined behavior.

Backpressure:

The operator honors the downstream backpressure and consumes the inner stream only on demand. The operator prefetches the given amount of upstream items and caches them until they are ready to be mapped into Streams after the current Stream has been consumed.

Scheduler:

flatMapStream does not operate by default on a particular Scheduler.

Type Parameters:

R - the element type of the Streams and the result

Parameters:

mapper - the function that receives an upstream item and should return a Stream whose elements will be emitted to the downstream

prefetch - the number of upstream items to request upfront, then 75% of this amount after each 75% upstream items received

Returns:

the new ParallelFlowable instance

Throws:

NullPointerException - if mapper is null

IllegalArgumentException - if prefetch is non-positive

Since:

3.0.0

See Also:

flatMap(Function, boolean, int), flatMapIterable(Function, int)

collect

@CheckReturnValue
 @NonNull
 @BackpressureSupport(value=UNBOUNDED_IN)
 @SchedulerSupport(value="none")
public final <A,R> @NonNull Flowable<R> collect(@NonNull Collector<T,A,R> collector)

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

Each parallel rail receives its own Collector.accumulator() and Collector.combiner().

Backpressure:

The operator honors backpressure from the downstream and consumes the upstream rails in an unbounded manner (requesting Long.MAX_VALUE).

Scheduler:

collect does not operate by default on a particular Scheduler.

Type Parameters:

A - the accumulator type

R - the output value type

Parameters:

collector - the Collector instance

Returns:

the new Flowable instance emitting the collected value.

Throws:

NullPointerException - if collector is null

Since:

3.0.0