Package io.servicetalk.concurrent.api

Class Publisher<T>

java.lang.Object

io.servicetalk.concurrent.api.Publisher<T>

Type Parameters:

T - Type of items emitted.

Direct Known Subclasses:

GroupedPublisher, SubscribablePublisher, TestPublisher

public abstract class Publisher<T>
extends java.lang.Object

An asynchronous computation that produces 0, 1 or more elements and may or may not terminate successfully or with an error.

How to subscribe?

This class does not provide a way to subscribe using a PublisherSource.Subscriber as such calls are ambiguous about the intent whether the subscribe is part of the same source (a.k.a an operator) or it is a terminal subscribe. If it is required to subscribe to a source, then a source adapter can be used to convert to a PublisherSource.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Publisher()	New instance.

Method Summary

Modifier and Type	Method	Description
Publisher<T>	afterCancel(java.lang.Runnable onCancel)	Invokes the onCancel Runnable argument after Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher.
Publisher<T>	afterFinally(TerminalSignalConsumer doFinally)	Invokes the corresponding method on afterFinally TerminalSignalConsumer argument after any of the following terminal methods are called: PublisherSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete() PublisherSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable) Cancellable.cancel() - invokes TerminalSignalConsumer.cancel() for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterFinally(java.lang.Runnable doFinally)	Invokes the afterFinally Runnable argument after any of the following terminal methods are called: PublisherSource.Subscriber.onComplete() PublisherSource.Subscriber.onError(Throwable) Cancellable.cancel() for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterOnComplete(java.lang.Runnable onComplete)	Invokes the onComplete Runnable argument after PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterOnError(java.util.function.Consumer<java.lang.Throwable> onError)	Invokes the onError Consumer argument after PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterOnNext(java.util.function.Consumer<? super T> onNext)	Invokes the onNext Consumer argument after PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterOnSubscribe(java.util.function.Consumer<? super PublisherSource.Subscription> onSubscribe)	Invokes the onSubscribe Consumer argument after PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterRequest(java.util.function.LongConsumer onRequest)	Invokes the onRequest LongConsumer argument after PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.
Publisher<T>	afterSubscriber(java.util.function.Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)	Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscriber methods after the PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	afterSubscription(java.util.function.Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)	Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscription methods after the PublisherSource.Subscriptions of the returned Publisher.
Publisher<T>	beforeCancel(java.lang.Runnable onCancel)	Invokes the onCancel Runnable argument before Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher.
Publisher<T>	beforeFinally(TerminalSignalConsumer doFinally)	Invokes the corresponding method on beforeFinally TerminalSignalConsumer argument before any of the following terminal methods are called: PublisherSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete() PublisherSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable) Cancellable.cancel() - invokes TerminalSignalConsumer.cancel() for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeFinally(java.lang.Runnable doFinally)	Invokes the beforeFinally Runnable argument before any of the following terminal methods are called: PublisherSource.Subscriber.onComplete() PublisherSource.Subscriber.onError(Throwable) Cancellable.cancel() for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeOnComplete(java.lang.Runnable onComplete)	Invokes the onComplete Runnable argument before PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeOnError(java.util.function.Consumer<java.lang.Throwable> onError)	Invokes the onError Consumer argument before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeOnNext(java.util.function.Consumer<? super T> onNext)	Invokes the onNext Consumer argument before PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeOnSubscribe(java.util.function.Consumer<? super PublisherSource.Subscription> onSubscribe)	Invokes the onSubscribe Consumer argument before PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeRequest(java.util.function.LongConsumer onRequest)	Invokes the onRequest LongConsumer argument before PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.
Publisher<T>	beforeSubscriber(java.util.function.Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)	Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) on each call to subscribe and invokes all the PublisherSource.Subscriber methods before the PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	beforeSubscription(java.util.function.Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)	Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) on each call to subscribe and invokes all the PublisherSource.Subscription methods before the PublisherSource.Subscriptions of the returned Publisher.
<BC extends BufferStrategy.Accumulator<T,B>,B> Publisher<B>	buffer(BufferStrategy<T,BC,B> strategy)	Create a Publisher that buffers items from this Publisher and emit those buffers instead of the individual items.
<R> Single<R>	collect(java.util.function.Supplier<? extends R> resultFactory, java.util.function.BiFunction<? super R,? super T,R> collector)	Collects all items emitted by this Publisher into a single item.
Completable	completableOrError()	Converts this Publisher to a Completable.
Publisher<T>	concat(Completable next)	Listens for completion of next Completable after this Publisher terminates successfully.
Publisher<T>	concat(Publisher<? extends T> next)	Emits items emitted by next Publisher after this Publisher terminates successfully.
Publisher<T>	concat(Single<? extends T> next)	Listens and emits the result of next Single after this Publisher terminates successfully.
static <T> Publisher<T>	defer(java.util.function.Supplier<? extends Publisher<? extends T>> publisherSupplier)	Defers creation of a Publisher till it is subscribed.
static <T> Publisher<T>	empty()	Creates a new Publisher that completes when subscribed without emitting any item to its PublisherSource.Subscriber.
static <T> Publisher<T>	failed(java.lang.Throwable cause)	Creates a new Publisher that terminates its PublisherSource.Subscriber with an error without emitting any item to it.
Publisher<T>	filter(java.util.function.Predicate<? super T> predicate)	Filters items emitted by this Publisher.
Single<T>	firstOrElse(java.util.function.Supplier<T> defaultValueSupplier)	Converts this Publisher to a Single.
Single<T>	firstOrError()	Ensures that this Publisher emits exactly a single PublisherSource.Subscriber.onNext(Object) to its PublisherSource.Subscriber.
Completable	flatMapCompletable(java.util.function.Function<? super T,? extends Completable> mapper)	Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.
Completable	flatMapCompletable(java.util.function.Function<? super T,? extends Completable> mapper, int maxConcurrency)	Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.
Completable	flatMapCompletableDelayError(java.util.function.Function<? super T,? extends Completable> mapper)	Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.
Completable	flatMapCompletableDelayError(java.util.function.Function<? super T,? extends Completable> mapper, int maxConcurrency)	Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.
Completable	flatMapCompletableDelayError(java.util.function.Function<? super T,? extends Completable> mapper, int maxConcurrency, int maxDelayedErrorsHint)	Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.
<R> Publisher<R>	flatMapConcatIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)	Create a Publisher that flattens each element returned by the Iterable.iterator() from mapper.
<R> Publisher<R>	flatMapMerge(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper)	Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMerge(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency)	Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeDelayError(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper)	Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeDelayError(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency)	Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeDelayError(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper, int maxConcurrency, int maxDelayedErrorsHint)	Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeSingle(java.util.function.Function<? super T,? extends Single<? extends R>> mapper)	Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeSingle(java.util.function.Function<? super T,? extends Single<? extends R>> mapper, int maxConcurrency)	Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeSingleDelayError(java.util.function.Function<? super T,? extends Single<? extends R>> mapper)	Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeSingleDelayError(java.util.function.Function<? super T,? extends Single<? extends R>> mapper, int maxConcurrency)	Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.
<R> Publisher<R>	flatMapMergeSingleDelayError(java.util.function.Function<? super T,? extends Single<? extends R>> mapper, int maxConcurrency, int maxDelayedErrorsHint)	Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.
Cancellable	forEach(java.util.function.Consumer<? super T> forEach)	Subscribes to this Publisher and invokes forEach Consumer for each item emitted by this Publisher.
static <T> Publisher<T>	from(T value)	Creates a new Publisher that emits value to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
static <T> Publisher<T>	from(T... values)	Creates a new Publisher that emits all values to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
static <T> Publisher<T>	fromBlockingIterable(BlockingIterable<? extends T> iterable, java.util.function.LongSupplier timeoutSupplier, java.util.concurrent.TimeUnit unit)	Create a new Publisher that when subscribed will get a BlockingIterator via BlockingIterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
static Publisher<byte[]>	fromInputStream(java.io.InputStream stream)	Create a new Publisher that when subscribed will emit all data from the InputStream to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
static <T> Publisher<T>	fromIterable(java.lang.Iterable<? extends T> iterable)	Create a new Publisher that when subscribed will get an Iterator via Iterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().
<Key> Publisher<GroupedPublisher<Key,T>>	groupBy(java.util.function.Function<? super T,? extends Key> keySelector, int groupMaxQueueSize)	Splits items from this Publisher into dynamically generated GroupedPublishers.
<Key> Publisher<GroupedPublisher<Key,T>>	groupBy(java.util.function.Function<? super T,? extends Key> keySelector, int groupMaxQueueSize, int expectedGroupCountHint)	Splits items from this Publisher into dynamically generated GroupedPublishers.
<Key> Publisher<GroupedPublisher<Key,T>>	groupToMany(java.util.function.Function<? super T,? extends java.util.Iterator<? extends Key>> keySelector, int groupMaxQueueSize)	The semantics are identical to groupBy(Function, int) except that the keySelector can map each data to multiple keys.
<Key> Publisher<GroupedPublisher<Key,T>>	groupToMany(java.util.function.Function<? super T,? extends java.util.Iterator<? extends Key>> keySelector, int groupMaxQueueSize, int expectedGroupCountHint)	The semantics are identical to groupBy(Function, int) except that the keySelector can map each data to multiple keys.
protected abstract void	handleSubscribe(PublisherSource.Subscriber<? super T> subscriber)	Handles a subscriber to this Publisher.
Publisher<T>	idleTimeout(long duration, java.util.concurrent.TimeUnit unit)	Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls.
Publisher<T>	idleTimeout(long duration, java.util.concurrent.TimeUnit unit, Executor timeoutExecutor)	Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls.
Publisher<T>	idleTimeout(java.time.Duration duration)	Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls.
Publisher<T>	idleTimeout(java.time.Duration duration, Executor timeoutExecutor)	Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls.
Completable	ignoreElements()	Ignores all elements emitted by this Publisher and forwards the termination signal to the returned Completable.
<R> Publisher<R>	liftAsync(PublisherOperator<? super T,? extends R> operator)	This method requires advanced knowledge of building operators.
<R> Publisher<R>	liftSync(PublisherOperator<? super T,? extends R> operator)	This method requires advanced knowledge of building operators.
<R> Single<R>	liftSyncToSingle(PublisherToSingleOperator<? super T,? extends R> operator)	This method requires advanced knowledge of building operators.
<R> Publisher<R>	map(java.util.function.Function<? super T,? extends R> mapper)	Transforms elements emitted by this Publisher into a different type.
Publisher<T>	multicastToExactly(int expectedSubscribers)	Create a Publisher that multicasts all the signals to exactly expectedSubscribers.
Publisher<T>	multicastToExactly(int expectedSubscribers, int maxQueueSize)	Create a Publisher that allows exactly expectedSubscribers subscribes.
static <T> Publisher<T>	never()	Creates a new Publisher that never emits any item to its PublisherSource.Subscriber and never call any terminal methods on it.
Publisher<T>	publishAndSubscribeOn(Executor executor)	Creates a new Publisher that will use the passed Executor to invoke the following methods: All PublisherSource.Subscriber methods. All PublisherSource.Subscription methods. The handleSubscribe(PublisherSource.Subscriber) method. This method does not override preceding Executors, if any, specified for this Publisher.
Publisher<T>	publishAndSubscribeOnOverride(Executor executor)	Creates a new Publisher that will use the passed Executor to invoke the following methods: All PublisherSource.Subscriber methods. All PublisherSource.Subscription methods. The handleSubscribe(PublisherSource.Subscriber) method. This method overrides preceding Executors, if any, specified for this Publisher.
Publisher<T>	publishOn(Executor executor)	Creates a new Publisher that will use the passed Executor to invoke all PublisherSource.Subscriber methods.
Publisher<T>	publishOnOverride(Executor executor)	Creates a new Publisher that will use the passed Executor to invoke all PublisherSource.Subscriber methods.
static Publisher<java.lang.Integer>	range(int begin, int end)	Create a new Publisher that when subscribed will emit all Integers within the range of [begin, end).
static Publisher<java.lang.Integer>	range(int begin, int end, int stride)	Create a new Publisher that when subscribed will emit all Integers within the range of [begin, end) with an increment of stride between each signal.
Publisher<T>	recoverWith(java.util.function.Function<java.lang.Throwable,? extends Publisher<? extends T>> nextFactory)	Recover from any error emitted by this Publisher by using another Publisher provided by the passed nextFactory.
Publisher<T>	repeat(java.util.function.IntPredicate shouldRepeat)	Re-subscribes to this Publisher when it completes and the passed IntPredicate returns true.
Publisher<T>	repeatWhen(java.util.function.IntFunction<? extends Completable> repeatWhen)	Re-subscribes to this Publisher when it completes and the Completable returned by the supplied IntFunction completes successfully.
Publisher<T>	retry(BiIntPredicate<java.lang.Throwable> shouldRetry)	Re-subscribes to this Publisher if an error is emitted and the passed BiIntPredicate returns true.
Publisher<T>	retryWhen(BiIntFunction<java.lang.Throwable,? extends Completable> retryWhen)	Re-subscribes to this Publisher if an error is emitted and the Completable returned by the supplied BiIntFunction completes successfully.
protected void	subscribeInternal(PublisherSource.Subscriber<? super T> subscriber)	A internal subscribe method similar to PublisherSource.subscribe(Subscriber) which can be used by different implementations to subscribe.
Publisher<T>	subscribeOn(Executor executor)	Creates a new Publisher that will use the passed Executor to invoke the following methods: All PublisherSource.Subscription methods. The handleSubscribe(PublisherSource.Subscriber) method. This method does not override preceding Executors, if any, specified for this Publisher.
Publisher<T>	subscribeOnOverride(Executor executor)	Creates a new Publisher that will use the passed Executor to invoke the following methods: All PublisherSource.Subscription methods. The handleSubscribe(PublisherSource.Subscriber) method. This method overrides preceding Executors, if any, specified for this Publisher.
Publisher<T>	subscribeShareContext()	Signifies that when the returned Publisher is subscribed to, the AsyncContext will be shared instead of making a copy.
Publisher<T>	takeAtMost(long numElements)	Takes at most numElements elements from this Publisher.
Publisher<T>	takeUntil(Completable until)	Takes elements until Completable is terminated successfully or with failure.
Publisher<T>	takeWhile(java.util.function.Predicate<? super T> predicate)	Takes elements while Predicate is true and then cancel PublisherSource.Subscription of this Publisher once it returns false.
java.util.concurrent.CompletionStage<java.util.Collection<T>>	toCompletionStage()	Convert this Publisher into a CompletionStage with a Collection containing the elements of this Publisher upon successful termination.
<R> java.util.concurrent.CompletionStage<R>	toCompletionStage(java.util.function.Supplier<? extends R> resultFactory, java.util.function.BiFunction<? super R,? super T,R> reducer)	Convert this Publisher into a CompletionStage of type Publisher which represents all elements of this Publisher upon successful termination.
java.util.concurrent.Future<java.util.Collection<T>>	toFuture()	Convert this Publisher into a Future with a Collection containing the elements of this Publisher upon successful termination.
<R> java.util.concurrent.Future<R>	toFuture(java.util.function.Supplier<? extends R> resultFactory, java.util.function.BiFunction<? super R,? super T,R> reducer)	Convert this Publisher into a Future of type Publisher which represents all elements of this Publisher upon successful termination.
java.io.InputStream	toInputStream(java.util.function.Function<? super T,byte[]> serializer)	Subscribes to this Publisher and converts all signals received by the PublisherSource.Subscriber to the returned InputStream following the below rules: PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required.
java.io.InputStream	toInputStream(java.util.function.Function<? super T,byte[]> serializer, int queueCapacity)	Subscribes to this Publisher and converts all signals received by the PublisherSource.Subscriber to the returned InputStream following the below rules: PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required.
BlockingIterable<T>	toIterable()	Converts this Publisher to an BlockingIterable.
BlockingIterable<T>	toIterable(int queueCapacityHint)	Converts this Publisher to an BlockingIterable.
Publisher<T>	whenCancel(java.lang.Runnable onCancel)	Invokes the onCancel Runnable argument when Cancellable.cancel() is called for Subscriptions of the returned Publisher.
Publisher<T>	whenFinally(TerminalSignalConsumer doFinally)	Invokes the corresponding method on whenFinally TerminalSignalConsumer argument when any of the following terminal methods are called: PublisherSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete() PublisherSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable) Cancellable.cancel() - invokes TerminalSignalConsumer.cancel() for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenFinally(java.lang.Runnable doFinally)	Invokes the whenFinally Runnable argument exactly once, when any of the following terminal methods are called: PublisherSource.Subscriber.onComplete() PublisherSource.Subscriber.onError(Throwable) Cancellable.cancel() for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenOnComplete(java.lang.Runnable onComplete)	Invokes the onComplete Runnable argument when PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenOnError(java.util.function.Consumer<java.lang.Throwable> onError)	Invokes the onError Consumer argument when PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenOnNext(java.util.function.Consumer<? super T> onNext)	Invokes the onNext Consumer argument when PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenOnSubscribe(java.util.function.Consumer<? super PublisherSource.Subscription> onSubscribe)	Invokes the onSubscribe Consumer argument when PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenRequest(java.util.function.LongConsumer onRequest)	Invokes the onRequest LongConsumer argument when PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.
Publisher<T>	whenSubscriber(java.util.function.Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)	Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) for each new subscribe and invokes methods on that PublisherSource.Subscriber when the corresponding methods are called for PublisherSource.Subscribers of the returned Publisher.
Publisher<T>	whenSubscription(java.util.function.Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)	Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscription methods when the corresponding methods are called for PublisherSource.Subscriptions of the returned Publisher.

Methods inherited from class java.lang.Object

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

Constructor Detail

Publisher

protected Publisher()

New instance.

Method Detail

map

public final <R> Publisher<R> map(java.util.function.Function<? super T,? extends R> mapper)

Transforms elements emitted by this Publisher into a different type.

This method provides a data transformation in sequential programming similar to:

     List<R> results = ...;
     for (T t : resultOfThisPublisher()) {
         results.add(mapper.apply(t));
     }
     return results;
 

Type Parameters:

R - Type of the items emitted by the returned Publisher.

Parameters:

mapper - Function to transform each item emitted by this Publisher.

Returns:

A Publisher that transforms elements emitted by this Publisher into a different type.

See Also:

ReactiveX map operator.

filter

public final Publisher<T> filter(java.util.function.Predicate<? super T> predicate)

Filters items emitted by this Publisher.

This method provides a data transformation in sequential programming similar to:

     List<T> results = ...;
     for (T t : resultOfThisPublisher()) {
         if (predicate.test(t)) {
             results.add(t);
         }
     }
     return results;
 

Parameters:

predicate - for the filter.

Returns:

A Publisher that only emits the items that pass the predicate.

See Also:

ReactiveX filter operator.

recoverWith

public final Publisher<T> recoverWith(java.util.function.Function<java.lang.Throwable,? extends Publisher<? extends T>> nextFactory)

Recover from any error emitted by this Publisher by using another Publisher provided by the passed nextFactory.

This method provides similar capabilities to a try/catch block in sequential programming:

     List<T> results;
     try {
         results = resultOfThisPublisher();
     } catch (Throwable cause) {
         // Note that nextFactory returning a error Publisher is like re-throwing (nextFactory shouldn't throw).
         results = nextFactory.apply(cause);
     }
     return results;
 

Parameters:

nextFactory - Returns the next Publisher, when this Publisher emits an error.

Returns:

A Publisher that recovers from an error from this Publisher by using another Publisher provided by the passed nextFactory.

See Also:

ReactiveX catch operator.

flatMapMerge

public final <R> Publisher<R> flatMapMerge(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper)

Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.

To control the amount of concurrent processing done by this operator see flatMapMerge(Function, int).

This method is similar to map(Function) but the result is an asynchronous stream, and provides a data transformation in sequential programming similar to:

     ExecutorService e = ...;
     List<Future<List<R>>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     List<R> results = new ArrayList<>(futures.size());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<List<R>> future : futures) {
         List<R> rList = future.get(); // Throws if the processing for this item failed.
         results.addAll(rList);
     }
     return results;
 

Type Parameters:

R - The type of mapped Publisher.

Parameters:

mapper - Convert each item emitted by this Publisher into another Publisher. each mapped Publisher.

Returns:

A new Publisher which flattens the emissions from all mapped Publishers.

See Also:

ReactiveX flatMap operator.

flatMapMerge

public final <R> Publisher<R> flatMapMerge(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper,
                                           int maxConcurrency)

Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.

This method is similar to map(Function) but the result is an asynchronous stream, and provides a data transformation in sequential programming similar to:

     ExecutorService e = ...;
     List<Future<List<R>>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     List<R> results = new ArrayList<>(futures.size());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<List<R>> future : futures) {
         List<R> rList = future.get(); // Throws if the processing for this item failed.
         results.addAll(rList);
     }
     return results;
 

Type Parameters:

R - The type of mapped Publisher.

Parameters:

mapper - Convert each item emitted by this Publisher into another Publisher.

maxConcurrency - Maximum amount of outstanding upstream demand.

Returns:

A new Publisher which flattens the emissions from all mapped Publishers.

See Also:

ReactiveX flatMap operator.

flatMapMergeDelayError

public final <R> Publisher<R> flatMapMergeDelayError(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper)

Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.

This is the same as flatMapMerge(Function) just that if any mapped Publisher returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all mapped Publishers to terminate and then terminate the returned Publisher with all errors emitted by the mapped Publishers.

To control the amount of concurrent processing done by this operator see flatMapMergeDelayError(Function, int).

This method is similar to map(Function) but the result is an asynchronous stream, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 List<R> rList = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.addAll(rList);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 

Type Parameters:

R - The type of mapped Publisher.

Parameters:

mapper - Convert each item emitted by this Publisher into another Publisher. each mapped Publisher.

Returns:

A new Publisher which flattens the emissions from all mapped Publishers.

See Also:

ReactiveX flatMap operator.

flatMapMergeDelayError

public final <R> Publisher<R> flatMapMergeDelayError(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper,
                                                     int maxConcurrency)

Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.

This is the same as flatMapMerge(Function) just that if any mapped Publisher returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all mapped Publishers to terminate and then terminate the returned Publisher with all errors emitted by the mapped Publishers.

This method is similar to map(Function) but the result is an asynchronous stream, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 List<R> rList = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.addAll(rList);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 

Type Parameters:

R - The type of mapped Publisher.

Parameters:

mapper - Convert each item emitted by this Publisher into another Publisher.

maxConcurrency - Maximum amount of outstanding upstream demand.

Returns:

A new Publisher which flattens the emissions from all mapped Publishers.

See Also:

ReactiveX flatMap operator.

flatMapMergeDelayError

public final <R> Publisher<R> flatMapMergeDelayError(java.util.function.Function<? super T,? extends Publisher<? extends R>> mapper,
                                                     int maxConcurrency,
                                                     int maxDelayedErrorsHint)

Map each element of this Publisher into a Publisher<Publisher> and flatten all signals emitted from each mapped Publisher<Publisher> into the returned Publisher<Publisher>.

This is the same as flatMapMerge(Function) just that if any mapped Publisher returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all mapped Publishers to terminate and then terminate the returned Publisher with all errors emitted by the mapped Publishers.

This method is similar to map(Function) but the result is an asynchronous stream, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 List<R> rList = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.addAll(rList);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 

Type Parameters:

R - The type of mapped Publisher.

Parameters:

mapper - Convert each item emitted by this Publisher into another Publisher.

maxConcurrency - Maximum amount of outstanding upstream demand.

maxDelayedErrorsHint - The maximum amount of errors that will be queued. After this point exceptions maybe discarded to reduce memory consumption.

Returns:

A new Publisher which flattens the emissions from all mapped Publishers.

See Also:

ReactiveX flatMap operator.

flatMapMergeSingle

public final <R> Publisher<R> flatMapMergeSingle(java.util.function.Function<? super T,? extends Single<? extends R>> mapper)

Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.

To control the amount of concurrent processing done by this operator see flatMapMergeSingle(Function, int).

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     ExecutorService e = ...;
     List<Future<R>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     List<R> results = new ArrayList<>(futures.size());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         R r = future.get(); // Throws if the processing for this item failed.
         results.add(r);
     }
     return results;
 

Type Parameters:

R - Type of items emitted by the returned Publisher.

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Single.

Returns:

A new Publisher that emits all items emitted by each single produced by mapper.

See Also:

ReactiveX flatMap operator., flatMapMergeSingle(Function, int)

flatMapMergeSingle

public final <R> Publisher<R> flatMapMergeSingle(java.util.function.Function<? super T,? extends Single<? extends R>> mapper,
                                                 int maxConcurrency)

Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     ExecutorService e = ...;
     List<Future<R>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     List<R> results = new ArrayList<>(futures.size());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         R r = future.get(); // Throws if the processing for this item failed.
         results.add(r);
     }
     return results;
 

Type Parameters:

R - Type of items emitted by the returned Publisher.

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Single.

maxConcurrency - Maximum active Singles at any time. Even if the number of items requested by a PublisherSource.Subscriber is more than this number, this will never request more than this number at any point.

Returns:

A new Publisher that emits all items emitted by each single produced by mapper.

See Also:

ReactiveX flatMap operator.

flatMapMergeSingleDelayError

public final <R> Publisher<R> flatMapMergeSingleDelayError(java.util.function.Function<? super T,? extends Single<? extends R>> mapper)

Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.

The behavior is the same as flatMapMergeSingle(Function, int) with the exception that if any Single returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all Singles to terminate and then terminate the returned Publisher with all errors emitted by the Singles produced by the mapper.

To control the amount of concurrent processing done by this operator see flatMapMergeSingleDelayError(Function, int).

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 R r = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.add(r);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 

Type Parameters:

R - Type of items emitted by the returned Publisher.

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Single.

Returns:

A new Publisher that emits all items emitted by each single produced by mapper.

See Also:

ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)

flatMapMergeSingleDelayError

public final <R> Publisher<R> flatMapMergeSingleDelayError(java.util.function.Function<? super T,? extends Single<? extends R>> mapper,
                                                           int maxConcurrency)

Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.

The behavior is the same as flatMapMergeSingle(Function, int) with the exception that if any Single returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all Singles to terminate and then terminate the returned Publisher with all errors emitted by the Singles produced by the mapper.

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 R r = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.add(r);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 

Type Parameters:

R - Type of items emitted by the returned Publisher.

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Single.

maxConcurrency - Maximum active Singles at any time. Even if the number of items requested by a PublisherSource.Subscriber is more than this number, this will never request more than this number at any point.

Returns:

A new Publisher that emits all items emitted by each single produced by mapper.

See Also:

ReactiveX merge operator.

flatMapMergeSingleDelayError

public final <R> Publisher<R> flatMapMergeSingleDelayError(java.util.function.Function<? super T,? extends Single<? extends R>> mapper,
                                                           int maxConcurrency,
                                                           int maxDelayedErrorsHint)

Map each element of this Publisher into a Single<Publisher> and flatten all signals emitted from each mapped Single<Publisher> into the returned Publisher<Publisher>.

The behavior is the same as flatMapMergeSingle(Function, int) with the exception that if any Single returned by mapper, terminates with an error, the returned Publisher will not immediately terminate. Instead, it will wait for this Publisher and all Singles to terminate and then terminate the returned Publisher with all errors emitted by the Singles produced by the mapper.

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<T> tResults = resultOfThisPublisher();
     List<R> rResults = ...; // assume this is thread safe
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 R r = mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
                 rResults.add(r);
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (errors.isEmpty()) {
         return rResults;
     }
     createAndThrowACompositeException(errors);
 

Type Parameters:

R - Type of items emitted by the returned Publisher.

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Single.

maxConcurrency - Maximum active Singles at any time. Even if the number of items requested by a PublisherSource.Subscriber is more than this number, this will never request more than this number at any point.

maxDelayedErrorsHint - The maximum amount of errors that will be queued. After this point exceptions maybe discarded to reduce memory consumption.

Returns:

A new Publisher that emits all items emitted by each single produced by mapper.

See Also:

ReactiveX merge operator.

flatMapCompletable

public final Completable flatMapCompletable(java.util.function.Function<? super T,? extends Completable> mapper)

Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.

If the returned Completable should wait for the termination of all mapped Completables when any one of them terminates with a failure, flatMapCompletableDelayError(Function) should be used.

To control the amount of concurrent processing done by this operator see flatMapCompletable(Function, int).

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Completable.

Returns:

A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.

See Also:

ReactiveX flatMap operator., flatMapCompletable(Function, int), flatMapCompletableDelayError(Function)

flatMapCompletable

public final Completable flatMapCompletable(java.util.function.Function<? super T,? extends Completable> mapper,
                                            int maxConcurrency)

Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.

If the returned Completable should wait for the termination of all mapped Completables when any one of them terminates with a failure, flatMapCompletableDelayError(Function) should be used.

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...; // assume this is thread safe
     for (T t : resultOfThisPublisher()) {
         // Note that flatMap process results in parallel.
         futures.add(e.submit(() -> {
             return mapper.apply(t); // Asynchronous result is flatten into a value by this operator.
         }));
     }
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<R> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Completable.

maxConcurrency - Maximum active Completables at any time.

Returns:

A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.

See Also:

ReactiveX flatMap operator., flatMapCompletable(Function), flatMapCompletableDelayError(Function, int)

flatMapCompletableDelayError

public final Completable flatMapCompletableDelayError(java.util.function.Function<? super T,? extends Completable> mapper)

Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.

If any mapped Completable terminates with an error the returned Completable will not immediately terminate. Instead, it will wait for this Publisher and all mapped Completables to terminate.

To control the amount of concurrent processing done by this operator see flatMapCompletableDelayError(Function, int).

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 mapper.apply(t); // Asynchronous result is flattened by this operator.
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (!errors.isEmpty()) {
         createAndThrowACompositeException(errors);
     }
 

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Completable.

Returns:

A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.

See Also:

ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)

flatMapCompletableDelayError

public final Completable flatMapCompletableDelayError(java.util.function.Function<? super T,? extends Completable> mapper,
                                                      int maxConcurrency)

Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.

If any mapped Completable terminates with an error the returned Completable will not immediately terminate. Instead, it will wait for this Publisher and all mapped Completables to terminate.

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 mapper.apply(t); // Asynchronous result is flattened by this operator.
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (!errors.isEmpty()) {
         createAndThrowACompositeException(errors);
     }
 

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Completable.

maxConcurrency - Maximum active Completables at any time.

Returns:

A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.

See Also:

ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)

flatMapCompletableDelayError

public final Completable flatMapCompletableDelayError(java.util.function.Function<? super T,? extends Completable> mapper,
                                                      int maxConcurrency,
                                                      int maxDelayedErrorsHint)

Map each element of this Publisher into a Completable and flatten all signals such that the returned Completable terminates when all mapped Completables have terminated successfully or any one of them has terminated with a failure.

If any mapped Completable terminates with an error the returned Completable will not immediately terminate. Instead, it will wait for this Publisher and all mapped Completables to terminate.

This method is similar to map(Function) but the result is asynchronous, and provides a data transformation in sequential programming similar to:

     Executor e = ...;
     List<Throwable> errors = ...;  // assume this is thread safe
     CountDownLatch latch =  new CountDownLatch(tResults.size());
     for (T t : tResults) {
         // Note that flatMap process results in parallel.
         e.execute(() -> {
             try {
                 mapper.apply(t); // Asynchronous result is flattened by this operator.
             } catch (Throwable cause) {
                 errors.add(cause);  // Asynchronous error is flatten into an error by this operator.
             } finally {
                 latch.countdown();
             }
         });
     }
     latch.await();
     if (!errors.isEmpty()) {
         createAndThrowACompositeException(errors);
     }
 

Parameters:

mapper - Function to convert each item emitted by this Publisher into a Completable.

maxConcurrency - Maximum active Completables at any time.

maxDelayedErrorsHint - The maximum amount of errors that will be queued. After this point exceptions maybe discarded to reduce memory consumption.

Returns:

A new Completable that terminates successfully if all the intermediate Completables have terminated successfully or any one of them has terminated with a failure.

See Also:

ReactiveX merge operator., flatMapMergeSingleDelayError(Function, int)

flatMapConcatIterable

public final <R> Publisher<R> flatMapConcatIterable(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends R>> mapper)

Create a Publisher that flattens each element returned by the Iterable.iterator() from mapper.

The mapper Function will only be called when the previously returned Iterator has returned false from Iterator.hasNext().

This method provides similar capabilities as expanding each result into a collection and concatenating each collection in sequential programming:

     List<R> results = ...;
     for (T t : resultOfThisPublisher()) {
         Iterable<? extends R> itr = mapper.apply(t);
         itr.forEach(results::add);
     }
     return results;
 

Type Parameters:

R - The elements returned by the Iterable.

Parameters:

mapper - A Function that returns an Iterable for each element.

Returns:

a Publisher that flattens each element returned by the Iterable.iterator() from mapper. The results will be sequential for each Iterator, and overall for all calls to Iterable.iterator()

whenOnSubscribe

public final Publisher<T> whenOnSubscribe(java.util.function.Consumer<? super PublisherSource.Subscription> onSubscribe)

Invokes the onSubscribe Consumer argument when PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.

The order in which onSubscribe will be invoked relative to PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is undefined. If you need strict ordering see beforeOnSubscribe(Consumer) and afterOnSubscribe(Consumer).

Parameters:

onSubscribe - Invoked when PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

beforeOnNext(Consumer), afterOnNext(Consumer)

whenOnNext

public final Publisher<T> whenOnNext(java.util.function.Consumer<? super T> onNext)

Invokes the onNext Consumer argument when PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.

The order in which onNext will be invoked relative to PublisherSource.Subscriber.onNext(Object) is undefined. If you need strict ordering see beforeOnNext(Consumer) and afterOnNext(Consumer).

From a sequential programming point of view this method is roughly equivalent to the following:

  for (T t: resultOfThisPublisher()) {
      // NOTE: The order of operations here is not guaranteed by this method!
      processNext(t);
      onNext.accept(t);
  }
 

Parameters:

onNext - Invoked when PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

beforeOnNext(Consumer), afterOnNext(Consumer)

whenOnComplete

public final Publisher<T> whenOnComplete(java.lang.Runnable onComplete)

Invokes the onComplete Runnable argument when PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.

The order in which onComplete will be invoked relative to PublisherSource.Subscriber.onComplete() is undefined. If you need strict ordering see beforeOnComplete(Runnable) and afterOnComplete(Runnable).

From a sequential programming point of view this method is roughly equivalent to the following:

  List<T> results = resultOfThisPublisher();
  // NOTE: The order of operations here is not guaranteed by this method!
  onSuccess.accept(results);
  nextOperation(results);
 

Parameters:

onComplete - Invoked when PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

beforeOnComplete(Runnable), afterOnComplete(Runnable)

whenOnError

public final Publisher<T> whenOnError(java.util.function.Consumer<java.lang.Throwable> onError)

Invokes the onError Consumer argument when PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.

The order in which onError will be invoked relative to PublisherSource.Subscriber.onError(Throwable) is undefined. If you need strict ordering see beforeOnError(Consumer) and afterOnError(Consumer).

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
    List<T> results = resultOfThisPublisher();
  } catch (Throwable cause) {
      // NOTE: The order of operations here is not guaranteed by this method!
      nextOperation(cause);
      onError.accept(cause);
  }
 

Parameters:

onError - Invoked before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

beforeOnError(Consumer), afterOnError(Consumer)

whenFinally

public final Publisher<T> whenFinally(java.lang.Runnable doFinally)

Invokes the whenFinally Runnable argument exactly once, when any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete()
• PublisherSource.Subscriber.onError(Throwable)
• Cancellable.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.

The order in which whenFinally will be invoked relative to the above methods is undefined. If you need strict ordering see beforeFinally(Runnable) and afterFinally(Runnable).

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
      List<T> results = resultOfThisPublisher();
  } finally {
      // NOTE: The order of operations here is not guaranteed by this method!
      nextOperation(); // Maybe notifying of cancellation, or termination
      doFinally.run();
  }
 

Parameters:

doFinally - Invoked exactly once, when any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete()
• PublisherSource.Subscriber.onError(Throwable)
• Cancellable.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

beforeFinally(Runnable), afterFinally(Runnable)

whenFinally

public final Publisher<T> whenFinally(TerminalSignalConsumer doFinally)

Invokes the corresponding method on whenFinally TerminalSignalConsumer argument when any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete()
• PublisherSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable)
• Cancellable.cancel() - invokes TerminalSignalConsumer.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.

The order in which whenFinally will be invoked relative to the above methods is undefined. If you need strict ordering see beforeFinally(TerminalSignalConsumer) and afterFinally(TerminalSignalConsumer).

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
      List<T> results = resultOfThisPublisher();
  } catch(Throwable t) {
      // NOTE: The order of operations here is not guaranteed by this method!
      nextOperation(); // Maybe notifying of cancellation, or termination
      doFinally.onError(t);
      return;
  }
  // NOTE: The order of operations here is not guaranteed by this method!
  nextOperation(); // Maybe notifying of cancellation, or termination
  doFinally.onComplete();
 

Parameters:

doFinally - For each subscribe of the returned Publisher, at most one method of this TerminalSignalConsumer will be invoked.

Returns:

The new Publisher.

See Also:

beforeFinally(TerminalSignalConsumer), afterFinally(TerminalSignalConsumer)

whenRequest

public final Publisher<T> whenRequest(java.util.function.LongConsumer onRequest)

Invokes the onRequest LongConsumer argument when PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.

Parameters:

onRequest - Invoked when PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

whenCancel

public final Publisher<T> whenCancel(java.lang.Runnable onCancel)

Invokes the onCancel Runnable argument when Cancellable.cancel() is called for Subscriptions of the returned Publisher.

The order in which whenFinally will be invoked relative to Cancellable.cancel() is undefined. If you need strict ordering see beforeCancel(Runnable) and afterCancel(Runnable).

Parameters:

onCancel - Invoked when Cancellable.cancel() is called for Subscriptions of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

beforeCancel(Runnable), afterCancel(Runnable)

idleTimeout

public final Publisher<T> idleTimeout(long duration,
                                      java.util.concurrent.TimeUnit unit)

Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.

In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.

Parameters:

duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.

unit - The units for duration.

Returns:

a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.

See Also:

ReactiveX timeout operator., idleTimeout(long, TimeUnit, io.servicetalk.concurrent.Executor)

idleTimeout

public final Publisher<T> idleTimeout(java.time.Duration duration)

Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.

In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.

Parameters:

duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.

Returns:

a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.

See Also:

ReactiveX timeout operator., idleTimeout(long, TimeUnit, io.servicetalk.concurrent.Executor)

idleTimeout

public final Publisher<T> idleTimeout(long duration,
                                      java.util.concurrent.TimeUnit unit,
                                      Executor timeoutExecutor)

Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.

In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.

Parameters:

duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.

unit - The units for duration.

timeoutExecutor - The Executor to use for managing the timer notifications.

Returns:

a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.

See Also:

ReactiveX timeout operator.

idleTimeout

public final Publisher<T> idleTimeout(java.time.Duration duration,
                                      Executor timeoutExecutor)

Creates a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between adjacent PublisherSource.Subscriber.onNext(Object) calls. The timer starts when the returned Publisher is subscribed.

In the event of timeout any PublisherSource.Subscription from PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) will be cancelled and the associated PublisherSource.Subscriber will be terminated.

Parameters:

duration - The time duration which is allowed to elapse between PublisherSource.Subscriber.onNext(Object) calls.

timeoutExecutor - The Executor to use for managing the timer notifications.

Returns:

a new Publisher that will mimic the signals of this Publisher but will terminate with a TimeoutException if time duration elapses between PublisherSource.Subscriber.onNext(Object) calls.

See Also:

ReactiveX timeout operator.

concat

public final Publisher<T> concat(Publisher<? extends T> next)

Emits items emitted by next Publisher after this Publisher terminates successfully.

This method provides a means to sequence the execution of two asynchronous sources and in sequential programming is similar to:

     List<T> results = resultOfThisPublisher();
     results.addAll(resultOfPublisher(next));
     return results;
 

Parameters:

next - Publisher's items that are emitted after this Publisher terminates successfully.

Returns:

A Publisher that emits all items from this Publisher and next Publisher.

See Also:

ReactiveX concat operator.

concat

public final Publisher<T> concat(Single<? extends T> next)

Listens and emits the result of next Single after this Publisher terminates successfully.

This method provides a means to sequence the execution of two asynchronous sources and in sequential programming is similar to:

     List<T> results = resultOfThisPublisher();
     results.add(resultOfSingle(next));
     return results;
 

Parameters:

next - Single's result that is emitted after this Publisher terminates successfully.

Returns:

A Publisher that emits all items from this Publisher and the result of next Single.

See Also:

ReactiveX concat operator.

concat

public final Publisher<T> concat(Completable next)

Listens for completion of next Completable after this Publisher terminates successfully. Any error from this Publisher and next Completable is forwarded to the returned Publisher.

This method provides a means to sequence the execution of two asynchronous sources and in sequential programming is similar to:

     List<T> results = resultOfThisPublisher();
     resultOfCompletable(next);
     return results;
 

Parameters:

next - Completable to wait for completion after this Publisher terminates successfully.

Returns:

A Publisher that emits all items from this Publisher and then awaits successful completion of next Completable.

See Also:

ReactiveX concat operator.

retry

public final Publisher<T> retry(BiIntPredicate<java.lang.Throwable> shouldRetry)

Re-subscribes to this Publisher if an error is emitted and the passed BiIntPredicate returns true.

This method provides a means to retry an operation under certain failure conditions and in sequential programming is similar to:

     public List<T> execute() {
         List<T> results = ...;
         return execute(0, results);
     }

     private List<T> execute(int attempts, List<T> results) {
         try {
             Iterator<T> itr = resultOfThisPublisher();
             while (itr.hasNext()) {
                 T t = itr.next(); // Any iteration with the Iterator may throw
                 results.add(t);
             }
             return results;
         } catch (Throwable cause) {
             if (shouldRetry.apply(attempts + 1, cause)) {
                 return execute(attempts + 1, results);
             } else {
                 throw cause;
             }
         }
     }
 

Parameters:

shouldRetry - BiIntPredicate that given the retry count and the most recent Throwable emitted from this Publisher determines if the operation should be retried.

Returns:

A Publisher that emits all items from this Publisher and re-subscribes if an error is emitted if the passed BiIntPredicate returned true.

See Also:

ReactiveX retry operator.

retryWhen

public final Publisher<T> retryWhen(BiIntFunction<java.lang.Throwable,? extends Completable> retryWhen)

Re-subscribes to this Publisher if an error is emitted and the Completable returned by the supplied BiIntFunction completes successfully. If the returned Completable emits an error, the returned Publisher terminates with that error.

This method provides a means to retry an operation under certain failure conditions in an asynchronous fashion and in sequential programming is similar to:

     public List<T> execute() {
         List<T> results = ...;
         return execute(0, results);
     }

     private List<T> execute(int attempts, List<T> results) {
         try {
             Iterator<T> itr = resultOfThisPublisher();
             while (itr.hasNext()) {
                 T t = itr.next(); // Any iteration with the Iterator may throw
                 results.add(t);
             }
             return results;
         } catch (Throwable cause) {
             try {
                 shouldRetry.apply(attempts + 1, cause); // Either throws or completes normally
                 execute(attempts + 1, results);
             } catch (Throwable ignored) {
                 throw cause;
             }
         }
     }
 

Parameters:

retryWhen - BiIntFunction that given the retry count and the most recent Throwable emitted from this Publisher returns a Completable. If this Completable emits an error, that error is emitted from the returned Publisher, otherwise, original Publisher is re-subscribed when this Completable completes.

Returns:

A Publisher that emits all items from this Publisher and re-subscribes if an error is emitted and Completable returned by BiIntFunction completes successfully.

See Also:

ReactiveX retry operator.

repeat

public final Publisher<T> repeat(java.util.function.IntPredicate shouldRepeat)

Re-subscribes to this Publisher when it completes and the passed IntPredicate returns true.

This method provides a means to repeat an operation multiple times and in sequential programming is similar to:

     List<T> results = new ...;
     int i = 0;
     do {
         results.addAll(resultOfThisPublisher());
     } while (shouldRepeat.test(++i));
     return results;
 

Parameters:

shouldRepeat - IntPredicate that given the repeat count determines if the operation should be repeated.

Returns:

A Publisher that emits all items from this Publisher and re-subscribes when it completes if the passed IntPredicate returns true.

See Also:

ReactiveX repeat operator.

repeatWhen

public final Publisher<T> repeatWhen(java.util.function.IntFunction<? extends Completable> repeatWhen)

Re-subscribes to this Publisher when it completes and the Completable returned by the supplied IntFunction completes successfully. If the returned Completable emits an error, the returned Publisher is completed.

This method provides a means to repeat an operation multiple times when in an asynchronous fashion and in sequential programming is similar to:

     List<T> results = new ...;
     int i = 0;
     while (true) {
         results.addAll(resultOfThisPublisher());
         try {
             repeatWhen.apply(++i); // Either throws or completes normally
         } catch (Throwable cause) {
             break;
         }
     }
     return results;
 

Parameters:

repeatWhen - IntFunction that given the repeat count returns a Completable. If this Completable emits an error repeat is terminated, otherwise, original Publisher is re-subscribed when this Completable completes.

Returns:

A Publisher that emits all items from this Publisher and re-subscribes if an error is emitted and Completable returned by IntFunction completes successfully.

See Also:

ReactiveX retry operator.

takeAtMost

public final Publisher<T> takeAtMost(long numElements)

Takes at most numElements elements from this Publisher.

If no terminal event is received before receiving numElements elements, PublisherSource.Subscription for the PublisherSource.Subscriber is cancelled.

This method provides a means to take a limited number of results from this Publisher and in sequential programming is similar to:

     List<T> results = ...;
     int i = 0;
     for (T t : resultOfThisPublisher()) {
         if (++i > numElements) {
             break;
         }
         results.add(t);
     }
     return results;
 

Parameters:

numElements - Number of elements to take.

Returns:

A Publisher that emits at most numElements elements from this Publisher.

See Also:

ReactiveX take operator.

takeWhile

public final Publisher<T> takeWhile(java.util.function.Predicate<? super T> predicate)

Takes elements while Predicate is true and then cancel PublisherSource.Subscription of this Publisher once it returns false.

This method provides a means to take a limited number of results from this Publisher and in sequential programming is similar to:

     List<T> results = ...;
     for (T t : resultOfThisPublisher()) {
         if (!predicate.test(result)) {
             break;
         }
         results.add(t);
     }
     return results;
 

Parameters:

predicate - Predicate that is checked before emitting any item to a PublisherSource.Subscriber. If this predicate returns true, that item is emitted, else PublisherSource.Subscription is cancelled.

Returns:

A Publisher that only emits the items as long as the Predicate.test(Object) method returns true.

See Also:

ReactiveX takeWhile operator.

takeUntil

public final Publisher<T> takeUntil(Completable until)

Takes elements until Completable is terminated successfully or with failure.

This method provides a means to take a limited number of results from this Publisher and in sequential programming is similar to:

     List<T> results = ...;
     for (T t : resultOfThisPublisher()) {
         if (isCompleted(until)) {
             break;
         }
         takeResults.add(t);
     }
     return results;
 

Parameters:

until - Completable, termination of which, terminates the returned Publisher.

Returns:

A Publisher that only emits the items till until Completable is completed.

See Also:

ReactiveX takeUntil operator.

groupBy

public final <Key> Publisher<GroupedPublisher<Key,T>> groupBy(java.util.function.Function<? super T,? extends Key> keySelector,
                                                                    int groupMaxQueueSize)

Splits items from this Publisher into dynamically generated GroupedPublishers. Item to group association is done by keySelector Function. If the selector selects a key which is previously seen and its associated PublisherSource.Subscriber has not yet cancelled its PublisherSource.Subscription, this item is sent to that PublisherSource.Subscriber. Otherwise a new GroupedPublisher is created and emitted from the returned Publisher.

Flow control

Multiple PublisherSource.Subscribers (for multiple GroupedPublishers) request items individually from this Publisher. Since, there is no way for a PublisherSource.Subscriber to only request elements for its group, elements requested by one group may end up producing items for a different group, which has not yet requested enough. This will cause items to be queued per group which can not be emitted due to lack of demand. This queue size can be controlled with the maxQueuePerGroup argument.

Cancellation

If the PublisherSource.Subscriber of the returned Publisher cancels its PublisherSource.Subscription, then all active GroupedPublishers will be terminated with an error and the PublisherSource.Subscription to this Publisher will be cancelled.

PublisherSource.Subscribers of individual GroupedPublishers can cancel their PublisherSource.Subscriptions at any point. If any new item is emitted for the cancelled GroupedPublisher, a new GroupedPublisher will be emitted from the returned Publisher. Any queued items for a cancelled PublisherSource.Subscriber for a GroupedPublisher will be discarded and hence will not be emitted if the same GroupedPublisher is emitted again.

In sequential programming this is similar to the following:

     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Key k = keySelector.apply(result);
         List<T> v = results.get(k);
         if (v == null) {
             v = // new List
             results.put(k, v);
         }
         v.add(result);
     }
     return results;
 

Type Parameters:

Key - Type of GroupedPublisher keys.

Parameters:

keySelector - Function to assign an item emitted by this Publisher to a GroupedPublisher.

groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).

Returns:

A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.

See Also:

ReactiveX groupBy operator.

groupBy

public final <Key> Publisher<GroupedPublisher<Key,T>> groupBy(java.util.function.Function<? super T,? extends Key> keySelector,
                                                                    int groupMaxQueueSize,
                                                                    int expectedGroupCountHint)

Splits items from this Publisher into dynamically generated GroupedPublishers. Item to group association is done by keySelector Function. If the selector selects a key which is previously seen and its associated PublisherSource.Subscriber has not yet cancelled its PublisherSource.Subscription, this item is sent to that PublisherSource.Subscriber. Otherwise a new GroupedPublisher is created and emitted from the returned Publisher.

Flow control

Multiple PublisherSource.Subscribers (for multiple GroupedPublishers) request items individually from this Publisher. Since, there is no way for a PublisherSource.Subscriber to only request elements for its group, elements requested by one group may end up producing items for a different group, which has not yet requested enough. This will cause items to be queued per group which can not be emitted due to lack of demand. This queue size can be controlled with the maxQueuePerGroup argument.

Cancellation

If the PublisherSource.Subscriber of the returned Publisher cancels its PublisherSource.Subscription, then all active GroupedPublishers will be terminated with an error and the PublisherSource.Subscription to this Publisher will be cancelled.

PublisherSource.Subscribers of individual GroupedPublishers can cancel their PublisherSource.Subscriptions at any point. If any new item is emitted for the cancelled GroupedPublisher, a new GroupedPublisher will be emitted from the returned Publisher. Any queued items for a cancelled PublisherSource.Subscriber for a GroupedPublisher will be discarded and hence will not be emitted if the same GroupedPublisher is emitted again.

In sequential programming this is similar to the following:

     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Key k = keySelector.apply(result);
         List<T> v = results.get(k);
         if (v == null) {
             v = // new List
             results.put(k, v);
         }
         v.add(result);
     }
     return results;
 

Type Parameters:

Key - Type of GroupedPublisher keys.

Parameters:

keySelector - Function to assign an item emitted by this Publisher to a GroupedPublisher.

groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).

expectedGroupCountHint - Expected number of groups that would be emitted by this Publisher. This is just a hint for internal data structures and does not have to be precise.

Returns:

A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.

See Also:

ReactiveX groupBy operator.

groupToMany

public final <Key> Publisher<GroupedPublisher<Key,T>> groupToMany(java.util.function.Function<? super T,? extends java.util.Iterator<? extends Key>> keySelector,
                                                                        int groupMaxQueueSize)

The semantics are identical to groupBy(Function, int) except that the keySelector can map each data to multiple keys.

In sequential programming this is similar to the following:

     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Iterator<Key> keys = keySelector.apply(result);
         for (Key key : keys) {
             List<T> v = results.get(key);
             if (v == null) {
                 v = // new List
                 results.put(key, v);
             }
             v.add(result);
         }
     }
     return results;
 

Type Parameters:

Key - Type of GroupedPublisher keys.

Parameters:

keySelector - Function to assign an item emitted by this Publisher to multiple GroupedPublishers.

groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).

Returns:

A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.

See Also:

groupBy(Function, int)

groupToMany

public final <Key> Publisher<GroupedPublisher<Key,T>> groupToMany(java.util.function.Function<? super T,? extends java.util.Iterator<? extends Key>> keySelector,
                                                                        int groupMaxQueueSize,
                                                                        int expectedGroupCountHint)

The semantics are identical to groupBy(Function, int) except that the keySelector can map each data to multiple keys.

In sequential programming this is similar to the following:

     Map<Key, List<T>> results = ...;
     for (T t : resultOfThisPublisher()) {
         Iterator<Key> keys = keySelector.apply(result);
         for (Key key : keys) {
             List<T> v = results.get(key);
             if (v == null) {
                 v = // new List
                 results.put(key, v);
             }
             v.add(result);
         }
     }
     return results;
 

Type Parameters:

Key - Type of GroupedPublisher keys.

Parameters:

keySelector - Function to assign an item emitted by this Publisher to multiple GroupedPublishers.

groupMaxQueueSize - Maximum number of new groups that will be queued due to the PublisherSource.Subscriber of the Publisher returned from this method not requesting enough via PublisherSource.Subscription.request(long).

expectedGroupCountHint - Expected number of groups that would be emitted by this Publisher. This is just a hint for internal data structures and does not have to be precise.

Returns:

A Publisher that emits GroupedPublishers for new keys as emitted by keySelector Function.

See Also:

groupBy(Function, int)

multicastToExactly

public final Publisher<T> multicastToExactly(int expectedSubscribers)

Create a Publisher that multicasts all the signals to exactly expectedSubscribers.

Depending on PublisherSource.Subscription.request(long) demand it is possible that data maybe queued before being delivered to each PublisherSource.Subscriber! For example if there are 2 PublisherSource.Subscribers and the first calls request(10), and the second only calls request(1), then 9 elements will be queued to deliver to second when more PublisherSource.Subscription.request(long) demand is made.

In sequential programming this is similar to the following:

     List<T> results = resultOfThisPublisher();
     List<List<T>> multiResults = ...;
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(results);
     }
     return multiResults;
 

Parameters:

expectedSubscribers - The number of expected subscribe calls required on the returned Publisher before subscribing to this Publisher.

Returns:

a Publisher that allows exactly expectedSubscribers subscribes.

multicastToExactly

public final Publisher<T> multicastToExactly(int expectedSubscribers,
                                             int maxQueueSize)

Create a Publisher that allows exactly expectedSubscribers subscribes. The events from this Publisher object will be delivered to each PublisherSource.Subscriber.

Depending on PublisherSource.Subscription.request(long) demand it is possible that data maybe queued before being delivered to each PublisherSource.Subscriber! For example if there are 2 PublisherSource.Subscribers and the first calls request(10), and the second only calls request(10), then 9 elements will be queued to deliver to second when more PublisherSource.Subscription.request(long) demand is made.

In sequential programming this is similar to the following:

     List<T> results = resultOfThisPublisher();
     List<List<T>> multiResults = ...;
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(results);
     }
     return multiResults;
 

Parameters:

expectedSubscribers - The number of expected subscribe calls required on the returned Publisher before subscribing to this Publisher.

maxQueueSize - The maximum number of PublisherSource.Subscriber.onNext(Object) events that will be queued if there is no demand for data before the PublisherSource.Subscriber will be discarded.

Returns:

a Publisher that allows exactly expectedSubscribers subscribes.

buffer

public final <BC extends BufferStrategy.Accumulator<T,B>,B> Publisher<B> buffer(BufferStrategy<T,BC,B> strategy)

Create a Publisher that buffers items from this Publisher and emit those buffers instead of the individual items.

In sequential programming this is similar to the following:

     List accumulators = strategy.boundaries();
     List buffers = ...;
     BC currentAccumulator;
     for (T t : resultOfThisPublisher()) {
         // This is an approximation; accumulators are emitted asynchronously.
         BC nextAccumulator = accumulators.remove(0).get();
         buffers.add(currentAccumulator.finish());
         currentAccumulator = nextAccumulator;
         currentAccumulator.add(t);
     }
     return buffers;
 

Type Parameters:

BC - Type of the BufferStrategy.Accumulator to buffer items from this Publisher.

B - Type of the buffer emitted from the returned Publisher.

Parameters:

strategy - A BufferStrategy to use for buffering items from this Publisher.

Returns:

a Publisher that buffers items from this Publisher and emit those buffers instead of the individual items.

See Also:

ReactiveX buffer operator.

beforeOnSubscribe

public final Publisher<T> beforeOnSubscribe(java.util.function.Consumer<? super PublisherSource.Subscription> onSubscribe)

Invokes the onSubscribe Consumer argument before PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.

Parameters:

onSubscribe - Invoked before PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeOnNext

public final Publisher<T> beforeOnNext(java.util.function.Consumer<? super T> onNext)

Invokes the onNext Consumer argument before PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  List<T> results = resultOfThisPublisher();
  for (T result : results) {
      onNext.accept(result);
  }
  nextOperation(results);
 

Parameters:

onNext - Invoked before PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeOnError

public final Publisher<T> beforeOnError(java.util.function.Consumer<java.lang.Throwable> onError)

Invokes the onError Consumer argument before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
    List<T> results = resultOfThisPublisher();
  } catch (Throwable cause) {
      onError.accept(cause);
      nextOperation(cause);
  }
 

Parameters:

onError - Invoked before PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeOnComplete

public final Publisher<T> beforeOnComplete(java.lang.Runnable onComplete)

Invokes the onComplete Runnable argument before PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

   List<T> results = resultOfThisPublisher();
   onComplete.run();
   nextOperation(results);
 

Parameters:

onComplete - Invoked before PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeRequest

public final Publisher<T> beforeRequest(java.util.function.LongConsumer onRequest)

Invokes the onRequest LongConsumer argument before PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.

Parameters:

onRequest - Invoked before PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeCancel

public final Publisher<T> beforeCancel(java.lang.Runnable onCancel)

Invokes the onCancel Runnable argument before Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher.

Parameters:

onCancel - Invoked before Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeFinally

public final Publisher<T> beforeFinally(java.lang.Runnable doFinally)

Invokes the beforeFinally Runnable argument before any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete()
• PublisherSource.Subscriber.onError(Throwable)
• Cancellable.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
      List<T> results = resultOfThisPublisher();
  } finally {
      doFinally.run();
      nextOperation(); // Maybe notifying of cancellation, or termination
  }
 

Parameters:

doFinally - Invoked before any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete()
• PublisherSource.Subscriber.onError(Throwable)
• Cancellable.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeFinally

public final Publisher<T> beforeFinally(TerminalSignalConsumer doFinally)

Invokes the corresponding method on beforeFinally TerminalSignalConsumer argument before any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete()
• PublisherSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable)
• Cancellable.cancel() - invokes TerminalSignalConsumer.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
      List<T> results = resultOfThisPublisher();
  } catch(Throwable t) {
      doFinally.onError(t);
      nextOperation(); // Maybe notifying of cancellation, or termination
      return;
  }
  doFinally.onComplete();
  nextOperation(); // Maybe notifying of cancellation, or termination
 

Parameters:

doFinally - For each subscribe of the returned Publisher, at most one method of this TerminalSignalConsumer will be invoked.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeSubscriber

public final Publisher<T> beforeSubscriber(java.util.function.Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)

Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) on each call to subscribe and invokes all the PublisherSource.Subscriber methods before the PublisherSource.Subscribers of the returned Publisher.

Parameters:

subscriberSupplier - Creates a new PublisherSource.Subscriber on each call to subscribe and invokes all the PublisherSource.Subscriber methods before the PublisherSource.Subscribers of the returned Publisher. PublisherSource.Subscriber methods MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

beforeSubscription

public final Publisher<T> beforeSubscription(java.util.function.Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)

Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) on each call to subscribe and invokes all the PublisherSource.Subscription methods before the PublisherSource.Subscriptions of the returned Publisher.

Parameters:

subscriptionSupplier - Creates a new PublisherSource.Subscription on each call to subscribe and invokes all the PublisherSource.Subscription methods before the PublisherSource.Subscriptions of the returned Publisher. PublisherSource.Subscription methods MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterOnSubscribe

public final Publisher<T> afterOnSubscribe(java.util.function.Consumer<? super PublisherSource.Subscription> onSubscribe)

Invokes the onSubscribe Consumer argument after PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher.

Parameters:

onSubscribe - Invoked after PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterOnNext

public final Publisher<T> afterOnNext(java.util.function.Consumer<? super T> onNext)

Invokes the onNext Consumer argument after PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  List<T> results = resultOfThisPublisher();
  nextOperation(results);
  for (T result : results) {
      onNext.accept(result);
  }
 

Parameters:

onNext - Invoked after PublisherSource.Subscriber.onNext(Object) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterOnError

public final Publisher<T> afterOnError(java.util.function.Consumer<java.lang.Throwable> onError)

Invokes the onError Consumer argument after PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
    List<T> results = resultOfThisPublisher();
  } catch (Throwable cause) {
      nextOperation(cause);
      onError.accept(cause);
  }
 

Parameters:

onError - Invoked after PublisherSource.Subscriber.onError(Throwable) is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterOnComplete

public final Publisher<T> afterOnComplete(java.lang.Runnable onComplete)

Invokes the onComplete Runnable argument after PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

   List<T> results = resultOfThisPublisher();
   nextOperation(results);
   onComplete.run();
 

Parameters:

onComplete - Invoked after PublisherSource.Subscriber.onComplete() is called for PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterRequest

public final Publisher<T> afterRequest(java.util.function.LongConsumer onRequest)

Invokes the onRequest LongConsumer argument after PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher.

Parameters:

onRequest - Invoked after PublisherSource.Subscription.request(long) is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterCancel

public final Publisher<T> afterCancel(java.lang.Runnable onCancel)

Invokes the onCancel Runnable argument after Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher.

Parameters:

onCancel - Invoked after Cancellable.cancel() is called for PublisherSource.Subscriptions of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterFinally

public final Publisher<T> afterFinally(java.lang.Runnable doFinally)

Invokes the afterFinally Runnable argument after any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete()
• PublisherSource.Subscriber.onError(Throwable)
• Cancellable.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
      List<T> results = resultOfThisPublisher();
  } finally {
      nextOperation(); // Maybe notifying of cancellation, or termination
      doFinally.run();
  }
 

Parameters:

doFinally - Invoked after any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete()
• PublisherSource.Subscriber.onError(Throwable)
• Cancellable.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher. MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterFinally

public final Publisher<T> afterFinally(TerminalSignalConsumer doFinally)

Invokes the corresponding method on afterFinally TerminalSignalConsumer argument after any of the following terminal methods are called:

• PublisherSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete()
• PublisherSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable)
• Cancellable.cancel() - invokes TerminalSignalConsumer.cancel()

for PublisherSource.Subscriptions/PublisherSource.Subscribers of the returned Publisher.

From a sequential programming point of view this method is roughly equivalent to the following:

  try {
      List<T> results = resultOfThisPublisher();
  } catch(Throwable t) {
      nextOperation(); // Maybe notifying of cancellation, or termination
      doFinally.onError(t);
      return;
  }
  nextOperation(); // Maybe notifying of cancellation, or termination
  doFinally.onComplete();
 

Parameters:

doFinally - For each subscribe of the returned Publisher, at most one method of this TerminalSignalConsumer will be invoked.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

afterSubscriber

public final Publisher<T> afterSubscriber(java.util.function.Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)

Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscriber methods after the PublisherSource.Subscribers of the returned Publisher.

Parameters:

subscriberSupplier - Creates a new PublisherSource.Subscriber for each new subscribe and invokes all the PublisherSource.Subscriber methods after the PublisherSource.Subscribers of the returned Publisher. PublisherSource.Subscriber methods MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

whenSubscriber

public final Publisher<T> whenSubscriber(java.util.function.Supplier<? extends PublisherSource.Subscriber<? super T>> subscriberSupplier)

Creates a new PublisherSource.Subscriber (via the subscriberSupplier argument) for each new subscribe and invokes methods on that PublisherSource.Subscriber when the corresponding methods are called for PublisherSource.Subscribers of the returned Publisher.

Parameters:

subscriberSupplier - Creates a new PublisherSource.Subscriber for each new subscribe and invokes methods on that PublisherSource.Subscriber when the corresponding methods are called for PublisherSource.Subscribers of the returned Publisher. PublisherSource.Subscriber methods MUST NOT throw.

Returns:

The new Publisher.

afterSubscription

public final Publisher<T> afterSubscription(java.util.function.Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)

Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscription methods after the PublisherSource.Subscriptions of the returned Publisher.

Parameters:

subscriptionSupplier - Creates a new PublisherSource.Subscription for each new subscribe and invokes all the PublisherSource.Subscription methods after the PublisherSource.Subscriptions of the returned Publisher. PublisherSource.Subscription methods MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

whenSubscription

public final Publisher<T> whenSubscription(java.util.function.Supplier<? extends PublisherSource.Subscription> subscriptionSupplier)

Creates a new PublisherSource.Subscription (via the subscriptionSupplier argument) for each new subscribe and invokes all the PublisherSource.Subscription methods when the corresponding methods are called for PublisherSource.Subscriptions of the returned Publisher.

Parameters:

subscriptionSupplier - Creates a new PublisherSource.Subscription for each new subscribe and invokes all the PublisherSource.Subscription methods when the PublisherSource.Subscriptions of the returned Publisher. PublisherSource.Subscription methods MUST NOT throw.

Returns:

The new Publisher.

See Also:

ReactiveX do operator.

forEach

public final Cancellable forEach(java.util.function.Consumer<? super T> forEach)

Subscribes to this Publisher and invokes forEach Consumer for each item emitted by this Publisher.

This will request Long.MAX_VALUE from the PublisherSource.Subscription.

From a sequential programming point of view this method is roughly equivalent to the following:

  List<T> results = resultOfThisPublisher();
  results.iterator().forEachRemaining(forEach);
 

Parameters:

forEach - Consumer to invoke for each PublisherSource.Subscriber.onNext(Object).

Returns:

Cancellable used to invoke Cancellable.cancel() on the parameter of PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) for this Publisher.

publishOn

public final Publisher<T> publishOn(Executor executor)

Creates a new Publisher that will use the passed Executor to invoke all PublisherSource.Subscriber methods. This method does not override preceding Executors, if any, specified for this Publisher. Only subsequent operations, if any, added in this execution chain will use this Executor. If such an override is required, publishOnOverride(Executor) can be used.

Parameters:

executor - Executor to use.

Returns:

A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscriber.

publishOnOverride

public final Publisher<T> publishOnOverride(Executor executor)

Creates a new Publisher that will use the passed Executor to invoke all PublisherSource.Subscriber methods. This method overrides preceding Executors, if any, specified for this Publisher. That is to say preceding and subsequent operations for this execution chain will use this Executor. If such an override is not required, publishOn(Executor) can be used.

Parameters:

executor - Executor to use.

Returns:

A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscriber both for the returned Publisher as well as this Publisher.

subscribeOn

public final Publisher<T> subscribeOn(Executor executor)

Creates a new Publisher that will use the passed Executor to invoke the following methods:

• All PublisherSource.Subscription methods.
• The handleSubscribe(PublisherSource.Subscriber) method.

This method does not override preceding Executors, if any, specified for this Publisher. Only subsequent operations, if any, added in this execution chain will use this Executor. If such an override is required, subscribeOnOverride(Executor) can be used.

Parameters:

executor - Executor to use.

Returns:

A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber).

subscribeOnOverride

public final Publisher<T> subscribeOnOverride(Executor executor)

Creates a new Publisher that will use the passed Executor to invoke the following methods:

• All PublisherSource.Subscription methods.
• The handleSubscribe(PublisherSource.Subscriber) method.

This method overrides preceding Executors, if any, specified for this Publisher. That is to say preceding and subsequent operations for this execution chain will use this Executor. If such an override is not required, subscribeOn(Executor) can be used.

Parameters:

executor - Executor to use.

Returns:

A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber) both for the returned Publisher as well as this Publisher.

publishAndSubscribeOn

public final Publisher<T> publishAndSubscribeOn(Executor executor)

Creates a new Publisher that will use the passed Executor to invoke the following methods:

• All PublisherSource.Subscriber methods.
• All PublisherSource.Subscription methods.
• The handleSubscribe(PublisherSource.Subscriber) method.

This method does not override preceding Executors, if any, specified for this Publisher. Only subsequent operations, if any, added in this execution chain will use this Executor. If such an override is required, publishAndSubscribeOnOverride(Executor) can be used.

Parameters:

executor - Executor to use.

Returns:

A new Publisher that will use the passed Executor to invoke all methods PublisherSource.Subscriber, PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber).

publishAndSubscribeOnOverride

public final Publisher<T> publishAndSubscribeOnOverride(Executor executor)

Creates a new Publisher that will use the passed Executor to invoke the following methods:

• All PublisherSource.Subscriber methods.
• All PublisherSource.Subscription methods.
• The handleSubscribe(PublisherSource.Subscriber) method.

This method overrides preceding Executors, if any, specified for this Publisher. That is to say preceding and subsequent operations for this execution chain will use this Executor. If such an override is not required, publishAndSubscribeOn(Executor) can be used.

Parameters:

executor - Executor to use.

Returns:

A new Publisher that will use the passed Executor to invoke all methods of PublisherSource.Subscriber, PublisherSource.Subscription and handleSubscribe(PublisherSource.Subscriber) both for the returned Publisher as well as this Publisher.

subscribeShareContext

public final Publisher<T> subscribeShareContext()

Signifies that when the returned Publisher is subscribed to, the AsyncContext will be shared instead of making a copy.

This operator only impacts behavior if the returned Publisher is subscribed directly after this operator, that means this must be the "last operator" in the chain for this to have an impact.

Returns:

A Publisher that will share the AsyncContext instead of making a copy when subscribed to.

liftSync

public final <R> Publisher<R> liftSync(PublisherOperator<? super T,? extends R> operator)

This method requires advanced knowledge of building operators. Before using this method please attempt to compose existing operator(s) to satisfy your use case.

Returns a Publisher which when subscribed, the operator argument will be used to wrap the PublisherSource.Subscriber before subscribing to this Publisher.

     Publisher<X> pub = ...;
     pub.map(..) // A
        .liftSync(original -> modified)
        .filter(..) // B
 

The original -> modified "operator" MUST be "synchronous" in that it does not interact with the original PublisherSource.Subscriber from outside the modified PublisherSource.Subscriber or PublisherSource.Subscription threads. That is to say this operator will not impact the Executor constraints already in place between A and B above. If you need asynchronous behavior, or are unsure, see liftAsync(PublisherOperator).

Type Parameters:

R - Type of the items emitted by the returned Publisher.

Parameters:

operator - The custom operator logic. The input is the "original" PublisherSource.Subscriber to this Publisher and the return is the "modified" PublisherSource.Subscriber that provides custom operator business logic.

Returns:

a Publisher which when subscribed, the operator argument will be used to wrap the PublisherSource.Subscriber before subscribing to this Publisher.

See Also:

liftAsync(PublisherOperator)

liftSyncToSingle

public final <R> Single<R> liftSyncToSingle(PublisherToSingleOperator<? super T,? extends R> operator)

This method requires advanced knowledge of building operators. Before using this method please attempt to compose existing operator(s) to satisfy your use case.

Returns a Single which when subscribed, the operator argument will be used to convert between the SingleSource.Subscriber to a PublisherSource.Subscriber before subscribing to this Publisher.

     Publisher<X> pub = ...;
     pub.map(..) // A
        .liftSync(original -> modified)
        .filter(..) // B - we have converted to Single now!
 

The original -> modified "operator" MUST be "synchronous" in that it does not interact with the original PublisherSource.Subscriber from outside the modified PublisherSource.Subscriber or PublisherSource.Subscription threads. That is to say this operator will not impact the Executor constraints already in place between A and B above. If you need asynchronous behavior, or are unsure, don't use this operator.

Type Parameters:

R - Type of the items emitted by the returned Single.

Parameters:

operator - The custom operator logic. The input is the "original" SingleSource.Subscriber to the returned Single and the return is the "modified" PublisherSource.Subscriber that provides custom operator business logic on this Publisher.

Returns:

a Single which when subscribed, the operator argument will be used to convert the SingleSource.Subscriber to a PublisherSource.Subscriber before subscribing to this Publisher.

liftAsync

public final <R> Publisher<R> liftAsync(PublisherOperator<? super T,? extends R> operator)

This method requires advanced knowledge of building operators. Before using this method please attempt to compose existing operator(s) to satisfy your use case.

Returns a Publisher which will wrap the PublisherSource.Subscriber using the provided operator argument before subscribing to this Publisher.

     Publisher<X> pub = ...;
     pub.map(..) // A
        .liftAsync(original -> modified)
        .filter(..) // B
 

The original -> modified "operator" MAY be "asynchronous" in that it may interact with the original PublisherSource.Subscriber from outside the modified PublisherSource.Subscriber or PublisherSource.Subscription threads. More specifically:

• all of the PublisherSource.Subscriber invocations going "downstream" (i.e. from A to B above) MAY be offloaded via an Executor
• all of the PublisherSource.Subscription invocations going "upstream" (i.e. from B to A above) MAY be offloaded via an Executor

This behavior exists to prevent blocking code negatively impacting the thread that powers the upstream source of data (e.g. an EventLoop).

Type Parameters:

R - Type of the items emitted by the returned Publisher.

Parameters:

operator - The custom operator logic. The input is the "original" PublisherSource.Subscriber to this Publisher and the return is the "modified" PublisherSource.Subscriber that provides custom operator business logic.

Returns:

a Publisher which when subscribed, the operator argument will be used to wrap the PublisherSource.Subscriber before subscribing to this Publisher.

See Also:

liftSync(PublisherOperator)

firstOrElse

public final Single<T> firstOrElse(java.util.function.Supplier<T> defaultValueSupplier)

Converts this Publisher to a Single.

Parameters:

defaultValueSupplier - A Supplier of default value if this Publisher did not emit any item.

Returns:

A Single that will contain the first item emitted from the this Publisher. If the source Publisher does not emit any item, then the returned Single will contain the value as returned by the passed Supplier.

See Also:

ReactiveX first operator.

firstOrError

public final Single<T> firstOrError()

Ensures that this Publisher emits exactly a single PublisherSource.Subscriber.onNext(Object) to its PublisherSource.Subscriber. If this Publisher terminates without emitting any items a NoSuchElementException will be signaled and if this Publisher emits more than one item, an IllegalArgumentException will be signaled. Any error emitted by this Publisher will be forwarded to the returned Single.

Returns:

A Single that will contain the first item emitted from the this Publisher. If the source Publisher does not emit any item, then the returned Single will terminate with NoSuchElementException.

ignoreElements

public final Completable ignoreElements()

Ignores all elements emitted by this Publisher and forwards the termination signal to the returned Completable.

Returns:

A Completable that mirrors the terminal signal from this Publisher.

See Also:

ReactiveX ignoreElements operator.

completableOrError

public final Completable completableOrError()

Converts this Publisher to a Completable. If this Publisher emits any PublisherSource.Subscriber.onNext(Object) signals the resulting Completable will be terminated with a IllegalArgumentException.

Returns:

A Completable that mirrors the terminal signal from this Publisher, and terminates in error if an PublisherSource.Subscriber.onNext(Object) signals.

collect

public final <R> Single<R> collect(java.util.function.Supplier<? extends R> resultFactory,
                                   java.util.function.BiFunction<? super R,? super T,R> collector)

Collects all items emitted by this Publisher into a single item.

Type Parameters:

R - Type of the reduced item.

Parameters:

resultFactory - Factory for the result which collects all items emitted by this Publisher. This will be called every time the returned Single is subscribed.

collector - Invoked for every item emitted by the source Publisher and returns the same or altered result object.

Returns:

A Single that completes with the single result or any error emitted by the source Publisher.

See Also:

ReactiveX reduce operator.

toFuture

public final java.util.concurrent.Future<java.util.Collection<T>> toFuture()

Convert this Publisher into a Future with a Collection containing the elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate Collection will be discarded and the Future will complete exceptionally.

Returns:

a Future with a Collection containing the elements of this Publisher upon successful termination.

See Also:

toFuture(Supplier, BiFunction)

toFuture

public final <R> java.util.concurrent.Future<R> toFuture(java.util.function.Supplier<? extends R> resultFactory,
                                                         java.util.function.BiFunction<? super R,? super T,R> reducer)

Convert this Publisher into a Future of type Publisher which represents all elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate Publisher will be discarded and the Future will complete exceptionally.

Type Parameters:

R - Type of the reduced item.

Parameters:

resultFactory - Factory for the result which collects all items emitted by this Publisher.

reducer - Invoked for every item emitted by the source Publisher and returns the same or altered result object.

Returns:

a Future of type Publisher which represents all elements of this Publisher upon successful termination.

toCompletionStage

public final java.util.concurrent.CompletionStage<java.util.Collection<T>> toCompletionStage()

Convert this Publisher into a CompletionStage with a Collection containing the elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate Collection will be discarded and the CompletionStage will complete exceptionally.

Returns:

a CompletionStage with a Collection containing the elements of this Publisher upon successful termination.

See Also:

toCompletionStage(Supplier, BiFunction)

toCompletionStage

public final <R> java.util.concurrent.CompletionStage<R> toCompletionStage(java.util.function.Supplier<? extends R> resultFactory,
                                                                           java.util.function.BiFunction<? super R,? super T,R> reducer)

Convert this Publisher into a CompletionStage of type Publisher which represents all elements of this Publisher upon successful termination. If this Publisher terminates in an error, then the intermediate Publisher will be discarded and the CompletionStage will complete exceptionally.

Type Parameters:

R - Type of the reduced item.

Parameters:

resultFactory - Factory for the result which collects all items emitted by this Publisher.

reducer - Invoked for every item emitted by the source Publisher and returns the same or altered result object.

Returns:

a CompletionStage of type Publisher which represents all elements of this Publisher upon successful termination.

toInputStream

public final java.io.InputStream toInputStream(java.util.function.Function<? super T,byte[]> serializer)

Subscribes to this Publisher and converts all signals received by the PublisherSource.Subscriber to the returned InputStream following the below rules:

• PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required. If the returned InputStream is closed, PublisherSource.Subscription is cancelled and any unread data is disposed.
• Any items received by PublisherSource.Subscriber.onNext(Object) are converted to a byte[] using the passed serializer. These bytes are available to be read from the InputStream
• Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in an IOException) when data is read from the returned InputStream. This error will be thrown only after draining all queued data, if any.
• When PublisherSource.Subscriber.onComplete() is called, returned InputStream's read methods will return -1 to indicate end of stream after emitting all received data.

Flow control

This operator may pre-fetch may pre-fetch items from this Publisher if available to reduce blocking for read operations from the returned InputStream. In order to increase responsiveness of the InputStream some amount of buffering may be done. Use toInputStream(Function, int) to manage capacity of this buffer.

Parameters:

serializer - Function that is invoked for every item emitted by this Publisher.

Returns:

InputStream that emits all data emitted by this Publisher. If this Publisher terminates with an error, same error is thrown (wrapped in an IOException) from the returned InputStreams read methods after emitting all received data.

toInputStream

public final java.io.InputStream toInputStream(java.util.function.Function<? super T,byte[]> serializer,
                                               int queueCapacity)

Subscribes to this Publisher and converts all signals received by the PublisherSource.Subscriber to the returned InputStream following the below rules:

• PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required. If the returned InputStream is closed, PublisherSource.Subscription is cancelled and any unread data is disposed.
• Any items received by PublisherSource.Subscriber.onNext(Object) are convertedto a byte[] using the passed serializer. These bytes are available to be read from the InputStream
• Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in an IOException) when data is read from the returned InputStream. This error will be thrown only after draining all queued data, if any.
• When PublisherSource.Subscriber.onComplete() is called, returned InputStream's read methods will return -1 to indicate end of stream after emitting all received data.

Flow control

This operator may pre-fetch items from this Publisher if available to reduce blocking for read operations from the returned InputStream. In order to increase responsiveness of the InputStream some amount of buffering may be done. queueCapacity can be used to bound this buffer.

Parameters:

serializer - Function that is invoked for every item emitted by this Publisher.

queueCapacity - Hint for the capacity of the intermediary queue that stores items that are emitted by this Publisher but has not yet been read from the returned InputStream.

Returns:

InputStream that emits all data emitted by this Publisher. If this Publisher terminates with an error, same error is thrown (wrapped in an IOException) from the returned InputStreams read methods after emitting all received data.

toIterable

public final BlockingIterable<T> toIterable()

Converts this Publisher to an BlockingIterable. Every time BlockingIterable.iterator() is called on the returned BlockingIterable, this Publisher is subscribed following the below rules:

• PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required.
• Any items received by PublisherSource.Subscriber.onNext(Object) is returned from a call to BlockingIterator.next().
• Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in a RuntimeException if required) when BlockingIterator.next() is called. This error will be thrown only after draining all queued data, if any.
• When PublisherSource.Subscriber.onComplete() is called, returned BlockingIterators Iterator.hasNext() will return false BlockingIterator.next() will throw NoSuchElementException. This error will be thrown only after draining all queued data, if any.

Flow control

This operator may pre-fetch items from this Publisher if available to reduce blocking of Iterator.hasNext() from the returned BlockingIterable. In order to increase responsiveness of the Iterator some amount of buffering may be done. Use toIterable(int) to manage capacity of this buffer.

Blocking

The returned BlockingIterator from the returned BlockingIterable will block on Iterator.hasNext() and BlockingIterator.next() if no data is available. This operator may try to reduce this blocking by requesting data ahead of time.

Returns:

BlockingIterable representing this Publisher. Every time BlockingIterable.iterator() is invoked on the BlockingIterable, this Publisher is subscribed. BlockingIterators returned from this BlockingIterable do not support Iterator.remove().

toIterable

public final BlockingIterable<T> toIterable(int queueCapacityHint)

Converts this Publisher to an BlockingIterable. Every time BlockingIterable.iterator() is called on the returned BlockingIterable, this Publisher is subscribed following the below rules:

• PublisherSource.Subscription received by PublisherSource.Subscriber.onSubscribe(PublisherSource.Subscription) is used to request more data when required.
• Any items received by PublisherSource.Subscriber.onNext(Object) is returned from a call to BlockingIterator.next().
• Any Throwable received by PublisherSource.Subscriber.onError(Throwable) is thrown (wrapped in a RuntimeException if required) when BlockingIterator.next(). This error will be thrown only after draining all queued data, if any.
• When PublisherSource.Subscriber.onComplete() is called, returned BlockingIterators Iterator.hasNext() will return false and BlockingIterator.next() will throw NoSuchElementException. This error will be thrown only after draining all queued data, if any.

Flow control

This operator may pre-fetch items from this Publisher if available to reduce blocking of Iterator.hasNext() from the returned BlockingIterable. In order to increase responsiveness of the BlockingIterator some amount of buffering may be done. queueCapacityHint can be used to bound this buffer.

Blocking

The returned BlockingIterator from the returned BlockingIterable will block on Iterator.hasNext() and BlockingIterator.next() if no data is available. This operator may try to reduce this blocking by requesting data ahead of time.

Parameters:

queueCapacityHint - Hint for the capacity of the intermediary queue that stores items that are emitted by this Publisher but has not yet been returned from the BlockingIterator.

Returns:

BlockingIterable representing this Publisher. Every time BlockingIterable.iterator() is invoked on the BlockingIterable, this Publisher is subscribed. BlockingIterators returned from this BlockingIterable do not support Iterator.remove().

subscribeInternal

protected final void subscribeInternal(PublisherSource.Subscriber<? super T> subscriber)

A internal subscribe method similar to PublisherSource.subscribe(Subscriber) which can be used by different implementations to subscribe.

Parameters:

subscriber - PublisherSource.Subscriber to subscribe for the result.

handleSubscribe

protected abstract void handleSubscribe(PublisherSource.Subscriber<? super T> subscriber)

Handles a subscriber to this Publisher.

Parameters:

subscriber - the subscriber.

from

public static <T> Publisher<T> from(@Nullable
                                    T value)

Creates a new Publisher that emits value to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

Type Parameters:

T - Type of items emitted by the returned Publisher.

Parameters:

value - Value that the returned Publisher will emit.

Returns:

A new Publisher that emits value to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

See Also:

ReactiveX just operator.

from

@SafeVarargs
public static <T> Publisher<T> from(T... values)

Creates a new Publisher that emits all values to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

Type Parameters:

T - Type of items emitted by the returned Publisher.

Parameters:

values - Values that the returned Publisher will emit.

Returns:

A new Publisher that emits all values to its PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

See Also:

ReactiveX from operator.

fromIterable

public static <T> Publisher<T> fromIterable(java.lang.Iterable<? extends T> iterable)

Create a new Publisher that when subscribed will get an Iterator via Iterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

The Reactive Streams specification provides two criteria ( 3.4, and 3.5) stating the PublisherSource.Subscription should be "responsive". The responsiveness of the associated PublisherSource.Subscriptions will depend upon the behavior of the iterable below. Make sure the Executor for this execution chain can tolerate this responsiveness and any blocking behavior.

Type Parameters:

T - Type of items emitted by the returned Publisher.

Parameters:

iterable - used to obtain instances of Iterator to extract data from. Iterable.iterator() must not return null. If this is of type BlockingIterable then any generated BlockingIterators will have their BlockingIterator.close() method called if an error occurs.

Returns:

a new Publisher that when subscribed will get an Iterator via Iterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

fromBlockingIterable

public static <T> Publisher<T> fromBlockingIterable(BlockingIterable<? extends T> iterable,
                                                    java.util.function.LongSupplier timeoutSupplier,
                                                    java.util.concurrent.TimeUnit unit)

Create a new Publisher that when subscribed will get a BlockingIterator via BlockingIterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

The Reactive Streams specification provides two criteria ( 3.4, and 3.5) stating the PublisherSource.Subscription should be "responsive". The responsiveness of the associated PublisherSource.Subscriptions will depend upon the behavior of the iterable below. Make sure the Executor for this execution chain can tolerate this responsiveness and any blocking behavior.

Type Parameters:

T - Type of items emitted by the returned Publisher.

Parameters:

iterable - used to obtain instances of Iterator to extract data from. Iterable.iterator() must not return null. Any generated BlockingIterators will have their BlockingIterator.close() method called if an error occurs.

timeoutSupplier - A LongSupplier which provides the time duration to wait for each interaction with iterable.

unit - The time units for the timeout duration.

Returns:

a new Publisher that when subscribed will get a BlockingIterator via BlockingIterable.iterator() and emit all values to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

fromInputStream

public static Publisher<byte[]> fromInputStream(java.io.InputStream stream)

Create a new Publisher that when subscribed will emit all data from the InputStream to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

The Reactive Streams specification provides two criteria ( 3.4, and 3.5) stating the PublisherSource.Subscription should be "responsive". The responsiveness of the associated PublisherSource.Subscriptions will depend upon the behavior of the stream below. Make sure the Executor for this execution chain can tolerate this responsiveness and any blocking behavior.

Parameters:

stream - provides the data in the form of byte[] to be emitted to the PublisherSource.Subscriber to the returned Publisher. Given the blocking nature of InputStream, assume PublisherSource.Subscription.request(long) can block when the underlying InputStream blocks on InputStream.read(byte[], int, int).

Returns:

a new Publisher that when subscribed will emit all data from the InputStream to the PublisherSource.Subscriber and then PublisherSource.Subscriber.onComplete().

range

public static Publisher<java.lang.Integer> range(int begin,
                                                 int end)

Create a new Publisher that when subscribed will emit all Integers within the range of [begin, end).

Parameters:

begin - The beginning of the range (inclusive).

end - The end of the range (exclusive).

Returns:

a new Publisher that when subscribed will emit all Integers within the range of [begin, end).

See Also:

Range.

range

public static Publisher<java.lang.Integer> range(int begin,
                                                 int end,
                                                 int stride)

Create a new Publisher that when subscribed will emit all Integers within the range of [begin, end) with an increment of stride between each signal.

Parameters:

begin - The beginning of the range (inclusive).

end - The end of the range (exclusive).

stride - The amount to increment in between each signal.

Returns:

a new Publisher that when subscribed will emit all Integers within the range of [begin, end) with an increment of stride between each signal.

See Also:

Range.

empty

public static <T> Publisher<T> empty()

Creates a new Publisher that completes when subscribed without emitting any item to its PublisherSource.Subscriber.

Type Parameters:

T - Type of items emitted by the returned Publisher.

Returns:

A new Publisher that completes when subscribed without emitting any item to its PublisherSource.Subscriber.

See Also:

ReactiveX empty operator.

never

public static <T> Publisher<T> never()

Creates a new Publisher that never emits any item to its PublisherSource.Subscriber and never call any terminal methods on it.

Type Parameters:

T - Type of items emitted by the returned Publisher.

Returns:

A new Publisher that never emits any item to its PublisherSource.Subscriber and never call any terminal methods on it.

See Also:

ReactiveX never operator.

failed

public static <T> Publisher<T> failed(java.lang.Throwable cause)

Creates a new Publisher that terminates its PublisherSource.Subscriber with an error without emitting any item to it.

Type Parameters:

T - Type of items emitted by the returned Publisher.

Parameters:

cause - The Throwable that is used to terminate the PublisherSource.Subscriber.

Returns:

A new Publisher that terminates its PublisherSource.Subscriber with an error without emitting any item to it.

See Also:

ReactiveX error operator.

defer

public static <T> Publisher<T> defer(java.util.function.Supplier<? extends Publisher<? extends T>> publisherSupplier)

Defers creation of a Publisher till it is subscribed.

Type Parameters:

T - Type of items emitted by the returned Publisher.

Parameters:

publisherSupplier - Supplier to create a new Publisher every time the returned Publisher is subscribed.

Returns:

A new Publisher that creates a new Publisher using publisherSupplier every time it is subscribed and forwards all items and terminal events from the newly created Publisher to its PublisherSource.Subscriber.

See Also:

ReactiveX defer operator.