Package io.servicetalk.concurrent.api

Class Completable

java.lang.Object

io.servicetalk.concurrent.api.Completable

Direct Known Subclasses:

SubscribableCompletable

public abstract class Completable
extends Object

An asynchronous computation that does not emit any data. It just completes or emits an error.

How to subscribe?

This class does not provide a way to subscribe using a CompletableSource.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 CompletableSource.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Completable()	New instance.

Method Summary

Modifier and Type	Method	Description
final Completable	afterCancel(Runnable onCancel)	Invokes the onCancel Runnable argument after Cancellable.cancel() is called for Subscriptions of the returned Completable.
final Completable	afterFinally(TerminalSignalConsumer doFinally)	Invokes the corresponding method on afterFinally TerminalSignalConsumer argument after any of the following terminal methods are called: CompletableSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete() CompletableSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable) Cancellable.cancel() - invokes TerminalSignalConsumer.cancel() for Subscriptions/CompletableSource.Subscribers of the returned Completable.
final Completable	afterFinally(Runnable doFinally)	Invokes the whenFinally Runnable argument after any of the following terminal methods are called: CompletableSource.Subscriber.onComplete() CompletableSource.Subscriber.onError(Throwable) Cancellable.cancel() for Subscriptions/CompletableSource.Subscribers of the returned Completable.
final Completable	afterOnComplete(Runnable onComplete)	Invokes the onComplete Runnable argument after CompletableSource.Subscriber.onComplete() is called for CompletableSource.Subscribers of the returned Completable.
final Completable	afterOnError(Consumer<Throwable> onError)	Invokes the onError Consumer argument after CompletableSource.Subscriber.onError(Throwable) is called for CompletableSource.Subscribers of the returned Completable.
final Completable	afterOnSubscribe(Consumer<Cancellable> onSubscribe)	Invokes the onSubscribe Consumer argument after CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable.
final Completable	afterSubscriber(Supplier<? extends CompletableSource.Subscriber> subscriberSupplier)	Creates a new CompletableSource.Subscriber (via the subscriberSupplier argument) on each call to subscribe and invokes all the CompletableSource.Subscriber methods after the CompletableSource.Subscribers of the returned Completable.
static Completable	amb(Completable... completables)	Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first.
static Completable	amb(Iterable<Completable> completables)	Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first.
final Completable	ambWith(Completable other)	Creates a new Completable that terminates with the result (either success or error) of either this Completable or the passed other Completable, whichever terminates first.
static Completable	anyOf(Completable... completables)	Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first.
static Completable	anyOf(Iterable<Completable> completables)	Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first.
final Completable	beforeCancel(Runnable onCancel)	Invokes the onCancel Runnable argument before Cancellable.cancel() is called for Subscriptions of the returned Completable.
final Completable	beforeFinally(TerminalSignalConsumer doFinally)	Invokes the corresponding method on beforeFinally TerminalSignalConsumer argument before any of the following terminal methods are called: CompletableSource.Subscriber.onComplete() - invokes TerminalSignalConsumer.onComplete() CompletableSource.Subscriber.onError(Throwable) - invokes TerminalSignalConsumer.onError(Throwable) Cancellable.cancel() - invokes TerminalSignalConsumer.cancel() for Subscriptions/CompletableSource.Subscribers of the returned Completable.
final Completable	beforeFinally(Runnable doFinally)	Invokes the whenFinally Runnable argument before any of the following terminal methods are called: CompletableSource.Subscriber.onComplete() CompletableSource.Subscriber.onError(Throwable) Cancellable.cancel() for Subscriptions/CompletableSource.Subscribers of the returned Completable.
final Completable	beforeOnComplete(Runnable onComplete)	Invokes the onComplete Runnable argument before CompletableSource.Subscriber.onComplete() is called for CompletableSource.Subscribers of the returned Completable.
final Completable	beforeOnError(Consumer<Throwable> onError)	Invokes the onError Consumer argument before CompletableSource.Subscriber.onError(Throwable) is called for CompletableSource.Subscribers of the returned Completable.
final Completable	beforeOnSubscribe(Consumer<Cancellable> onSubscribe)	Invokes the onSubscribe Consumer argument before CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable.
final Completable	beforeSubscriber(Supplier<? extends CompletableSource.Subscriber> subscriberSupplier)	Creates a new CompletableSource.Subscriber (via the subscriberSupplier argument) on each call to subscribe and invokes all the CompletableSource.Subscriber methods before the CompletableSource.Subscribers of the returned Completable.
final Completable	cache()	Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers.
final Completable	cache(int minSubscribers)	Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers.
final Completable	cache(int minSubscribers, boolean cancelUpstream)	Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers.
final Completable	cache(int minSubscribers, boolean cancelUpstream, Function<Throwable,Completable> terminalResubscribe)	Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers.
static Completable	completed()	Creates a realized completed Completable.
final Completable	concat(Completable next)	Once this Completable is terminated successfully, subscribe to next Completable and propagate its terminal signal to the returned Completable.
final Completable	concat(Completable... nexts)	Once this Completable is terminated successfully, subscribe to each Completable in nexts in a sequential fashion after termination, and the final terminal signals is propagated to the returned Completable.
final <T> Publisher<T>	concat(Publisher<? extends T> next)	Once this Completable is terminated successfully, subscribe to next Publisher and propagate all emissions to the returned Publisher.
final <T> Single<T>	concat(Single<? extends T> next)	Once this Completable is terminated successfully, subscribe to next Single and propagate the result to the returned Single.
static Completable	defer(Supplier<? extends Completable> completableSupplier)	Defer creation of a Completable till it is subscribed to.
static Completable	failed(Throwable cause)	Creates a realized failed Completable.
static Completable	fromCallable(Callable<Void> callable)	Creates a Completable which when subscribed will invoke Callable.call() on the passed Callable and emit the value returned by that invocation from the returned Completable.
static Completable	fromFuture(Future<?> future)	Convert from a Future to a Completable via Future.get().
static Completable	fromRunnable(Runnable runnable)	Creates a Completable which when subscribed will invoke Runnable.run() on the passed Runnable and emit the value returned by that invocation from the returned Completable.
static Completable	fromStage(CompletionStage<?> stage)	Convert from a CompletionStage to a Completable.
protected abstract void	handleSubscribe(CompletableSource.Subscriber subscriber)	Handles a subscriber to this Completable.
final Completable	liftAsync(CompletableOperator operator)	This method requires advanced knowledge of building operators.

Methods inherited from class java.lang.Object

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

Constructor Details

Completable

protected Completable()

New instance.

Method Details

onErrorComplete

public final Completable onErrorComplete()

Transform errors emitted on this Completable into a CompletableSource.Subscriber.onComplete() signal (e.g. swallows the error).

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         // ignored
     }
 

Returns:

A Completable which transform errors emitted on this Completable into a CompletableSource.Subscriber.onComplete() signal (e.g. swallows the error).

See Also:

• ReactiveX catch operator.

onErrorComplete

public final <E extends Throwable> Completable onErrorComplete(Class<E> type)

Transform errors emitted on this Completable which match type into a CompletableSource.Subscriber.onComplete() signal (e.g. swallows the error).

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         if (!type.isInstance(cause)) {
           throw cause;
         }
     }
 

Type Parameters:

E - The Throwable type.

Parameters:

type - The Throwable type to filter, operator will not apply for errors which don't match this type.

Returns:

A Completable which transform errors emitted on this Completable which match type into a CompletableSource.Subscriber.onComplete() signal (e.g. swallows the error).

See Also:

• ReactiveX catch operator.

onErrorComplete

public final Completable onErrorComplete(Predicate<? super Throwable> predicate)

Transform errors emitted on this Completable which match predicate into a CompletableSource.Subscriber.onComplete() signal (e.g. swallows the error).

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         if (!predicate.test(cause)) {
           throw cause;
         }
     }
 

Parameters:

predicate - returns true if the Throwable should be transformed to an CompletableSource.Subscriber.onComplete() signal. Returns false to propagate the error.

Returns:

A Completable which transform errors emitted on this Completable which match predicate into a CompletableSource.Subscriber.onComplete() signal (e.g. swallows the error).

See Also:

• ReactiveX catch operator.

onErrorMap

public final Completable onErrorMap(Function<? super Throwable,? extends Throwable> mapper)

Transform errors emitted on this Completable into a different error.

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         throw mapper.apply(cause);
     }
 

Parameters:

mapper - returns the error used to terminate the returned Completable.

Returns:

A Completable which transform errors emitted on this Completable into a different error.

See Also:

• ReactiveX catch operator.

onErrorMap

public final <E extends Throwable> Completable onErrorMap(Class<E> type,
 Function<? super E,? extends Throwable> mapper)

Transform errors emitted on this Completable which match type into a different error.

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         if (type.isInstance(cause)) {
           throw mapper.apply(cause);
         } else {
           throw cause;
         }
     }
 

Type Parameters:

E - The type of Throwable to transform.

Parameters:

type - The Throwable type to filter, operator will not apply for errors which don't match this type.

mapper - returns the error used to terminate the returned Completable.

Returns:

A Completable which transform errors emitted on this Completable into a different error.

See Also:

• ReactiveX catch operator.

onErrorMap

public final Completable onErrorMap(Predicate<? super Throwable> predicate,
 Function<? super Throwable,? extends Throwable> mapper)

Transform errors emitted on this Completable which match predicate into a different error.

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         if (predicate.test(cause)) {
           throw mapper.apply(cause);
         } else {
           throw cause;
         }
     }
 

Parameters:

predicate - returns true if the Throwable should be transformed via mapper. Returns false to propagate the original error.

mapper - returns the error used to terminate the returned Completable.

Returns:

A Completable which transform errors emitted on this Completable into a different error.

See Also:

• ReactiveX catch operator.

onErrorResume

public final Completable onErrorResume(Function<? super Throwable,? extends Completable> nextFactory)

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

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         // Note that nextFactory returning a error Completable is like re-throwing (nextFactory shouldn't throw).
         nextFactory.apply(cause);
     }
 

Parameters:

nextFactory - Returns the next Completable, if this Completable emits an error.

Returns:

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

onErrorResume

public final <E extends Throwable> Completable onErrorResume(Class<E> type,
 Function<? super E,? extends Completable> nextFactory)

Recover from errors emitted by this Completable which match type by using another Completable provided by the passed nextFactory.

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         if (type.isInstance(cause)) {
           // Note nextFactory returning a error Completable is like re-throwing (nextFactory shouldn't throw).
           results = nextFactory.apply(cause);
         } else {
           throw cause;
         }
     }
 

Type Parameters:

E - The type of Throwable to transform.

Parameters:

type - The Throwable type to filter, operator will not apply for errors which don't match this type.

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

Returns:

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

See Also:

• ReactiveX catch operator.

onErrorResume

public final Completable onErrorResume(Predicate<? super Throwable> predicate,
 Function<? super Throwable,? extends Completable> nextFactory)

Recover from errors emitted by this Completable which match predicate by using another Completable provided by the passed nextFactory.

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

     try {
         resultOfThisCompletable();
     } catch (Throwable cause) {
         if (predicate.test(cause)) {
           // Note that nextFactory returning a error Publisher is like re-throwing (nextFactory shouldn't throw).
           results = nextFactory.apply(cause);
         } else {
           throw cause;
         }
     }
 

Parameters:

predicate - returns true if the Throwable should be transformed via nextFactory. Returns false to propagate the original error.

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

Returns:

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

See Also:

• ReactiveX catch operator.

whenOnComplete

public final Completable whenOnComplete(Runnable onComplete)

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

The order in which onComplete will be invoked relative to CompletableSource.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:

  // NOTE: The order of operations here is not guaranteed by this method!
  nextOperation(result);
  onComplete.run();
 

Parameters:

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

Returns:

The new Completable.

See Also:

• beforeOnComplete(Runnable)
• afterOnComplete(Runnable)

whenOnError

public final Completable whenOnError(Consumer<Throwable> onError)

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

The order in which onError will be invoked relative to CompletableSource.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 {
    resultOfThisCompletable();
  } catch (Throwable cause) {
      // NOTE: The order of operations here is not guaranteed by this method!
      nextOperation(cause);
      onError.accept(cause);
  }
 

Parameters:

onError - Invoked when CompletableSource.Subscriber.onError(Throwable) is called for CompletableSource.Subscribers of the returned Completable. MUST NOT throw.

Returns:

The new Completable.

See Also:

• beforeOnError(Consumer)
• afterOnError(Consumer)

whenFinally

public final Completable whenFinally(Runnable doFinally)

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable.

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 {
      resultOfThisCompletable();
  } 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:

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable MUST NOT throw.

Returns:

The new Completable.

See Also:

• beforeFinally(Runnable)
• afterFinally(Runnable)

whenFinally

public final Completable whenFinally(TerminalSignalConsumer doFinally)

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable.

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 {
      resultOfThisCompletable();
  } 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 Completable, at most one method of this TerminalSignalConsumer will be invoked.

Returns:

The new Completable.

See Also:

• beforeFinally(TerminalSignalConsumer)
• afterFinally(TerminalSignalConsumer)

whenCancel

public final Completable whenCancel(Runnable onCancel)

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

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 Completable. MUST NOT throw.

Returns:

The new Completable.

See Also:

• beforeCancel(Runnable)
• afterCancel(Runnable)

timeout

public final Completable timeout(long duration,
 TimeUnit unit)

Creates a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses between subscribe and termination. The timer starts when the returned Completable is subscribed.

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

Parameters:

duration - The time duration which is allowed to elapse before CompletableSource.Subscriber.onComplete().

unit - The units for duration.

Returns:

a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses before CompletableSource.Subscriber.onComplete().

See Also:

• ReactiveX timeout operator.

timeout

public final Completable timeout(long duration,
 TimeUnit unit,
 Executor timeoutExecutor)

Creates a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses between subscribe and termination. The timer starts when the returned Completable is subscribed.

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

Parameters:

duration - The time duration which is allowed to elapse before CompletableSource.Subscriber.onComplete().

unit - The units for duration.

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

Returns:

a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses before CompletableSource.Subscriber.onComplete().

See Also:

• ReactiveX timeout operator.

timeout

public final Completable timeout(Duration duration)

Creates a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses between subscribe and termination. The timer starts when the returned Completable is subscribed.

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

Parameters:

duration - The time duration which is allowed to elapse before CompletableSource.Subscriber.onComplete().

Returns:

a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses before CompletableSource.Subscriber.onComplete().

See Also:

• ReactiveX timeout operator.

timeout

public final Completable timeout(Duration duration,
 Executor timeoutExecutor)

Creates a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses between subscribe and termination. The timer starts when the returned Completable is subscribed.

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

Parameters:

duration - The time duration which is allowed to elapse before CompletableSource.Subscriber.onComplete().

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

Returns:

a new Completable that will mimic the signals of this Completable but will terminate with a TimeoutException if time duration elapses before CompletableSource.Subscriber.onComplete().

See Also:

• ReactiveX timeout operator.

concat

public final Completable concat(Completable next)

Once this Completable is terminated successfully, subscribe to next Completable and propagate its terminal signal to the returned Completable. Any error from this Completable or next Completable are propagated to the returned Completable.

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

     resultOfThisCompletable();
     nextCompletable();
 

Parameters:

next - Completable to subscribe after this Completable terminates successfully.

Returns:

A Completable that emits the terminal signal of next Completable, after this Completable has terminated successfully.

concat

public final Completable concat(Completable... nexts)

Once this Completable is terminated successfully, subscribe to each Completable in nexts in a sequential fashion after termination, and the final terminal signals is propagated to the returned Completable. Any error from this Completable or from nexts Completable are propagated to the returned Completable.

This method provide equivalent functionality as:

   Completable original = ...;
   Completable[] nexts  = ...;
   Completable result = original;
   for (int i = 0; i < nexts.length; ++i) {
       result = result.concat(nexts[i]);
   }
   return result;
 

Parameters:

nexts - Completables to subscribe after this Completable terminates successfully.

Returns:

A Completable that emits the terminal signal of nexts Completables, after this Completable has terminated successfully.

concat

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

Once this Completable is terminated successfully, subscribe to next Single and propagate the result to the returned Single. Any error from this Completable or next Single are propagated to the returned Single.

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

     resultOfThisCompletable();
     T result = resultOfNextSingle();
     return result;
 

Type Parameters:

T - Type of result of the returned Single.

Parameters:

next - Single to subscribe after this Completable terminates successfully.

Returns:

A Single that emits the result of next Single, after this Completable has terminated successfully.

concat

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

Once this Completable is terminated successfully, subscribe to next Publisher and propagate all emissions to the returned Publisher. Any error from this Completable or next Publisher are propagated 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 = new ...;
     resultOfThisCompletable();
     results.addAll(nextStream());
     return results;
 

Type Parameters:

T - Type of objects emitted from the returned Publisher.

Parameters:

next - Publisher to subscribe after this Completable terminates successfully.

Returns:

A Publisher that emits all items emitted from next Publisher, after this Completable has terminated successfully.

merge

public final Completable merge(Completable other)

Merges this Completable with the other Completable so that the resulting Completable terminates successfully when both of these complete or either terminates with an error.

This method provides a means to merge multiple asynchronous sources, fails-fast in the presence of any errors, and in sequential programming is similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     futures.add(e.submit(() -> resultOfCompletable(other));
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 

Parameters:

other - Completables to merge.

Returns:

Completable that terminates successfully when this and other Completables complete or terminates with an error when either terminates with an error.

merge

public final Completable merge(Completable... other)

Merges this Completable with the other Completables so that the resulting Completable terminates successfully when all of these complete or any one terminates with an error.

This method provides a means to merge multiple asynchronous sources, fails-fast in the presence of any errors, and in sequential programming is similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     for (Completable c : other) {
         futures.add(e.submit(() -> resultOfCompletable(c));
     }
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 

Parameters:

other - Completables to merge.

Returns:

Completable that terminates successfully when this and all other Completables complete or terminates with an error when any one terminates with an error.

merge

public final Completable merge(Iterable<? extends Completable> other)

Merges this Completable with the other Completables so that the resulting Completable terminates successfully when all of these complete or terminates with an error when any one terminates with an error.

This method provides a means to merge multiple asynchronous sources, fails-fast in the presence of any errors, and in sequential programming is similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     for (Completable c : other) {
         futures.add(e.submit(() -> resultOfCompletable(c));
     }
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         future.get(); // Throws if the processing for this item failed.
     }
 

Parameters:

other - Completables to merge.

Returns:

Completable that terminates successfully when this and all other Completables complete or terminates with an error when any one terminates with an error.

merge

public final <T> Publisher<T> merge(Publisher<? extends T> mergeWith)

Merges the passed Publisher with this Completable.

The resulting Publisher emits all items emitted by the passed Publisher and terminates successfully when both this Completable and the passed Publisher terminates successfully. It terminates with an error when any one of this Completable or passed Publisher terminates with an error.

     ExecutorService e = ...;
     Future<?> future1 = e.submit(() -> resultOfThisCompletable()));
     Future<?> future2 = e.submit(() -> resultOfMergeWithStream());
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     future1.get(); // Throws if this Completable failed.
     future2.get(); // Throws if mergeWith Publisher failed.
 

Type Parameters:

T - The value type of the resulting Publisher.

Parameters:

mergeWith - the Publisher to merge in

Returns:

Publisher that emits all items emitted by the passed Publisher and terminates successfully when both this Completable and the passed Publisher terminates successfully. It terminates with an error when any one of this Completable or passed Publisher terminates with an error.

See Also:

• ReactiveX merge operator.

mergeDelayError

public final <T> Publisher<T> mergeDelayError(Publisher<? extends T> mergeWith)

Merges the passed Publisher with this Completable.

The resulting Publisher emits all items emitted by the passed Publisher and terminates when both this Completable and the passed Publisher terminate. If either terminates with an error then the error will be propagated to the return value.

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     futures.add(e.submit(() -> resultOfMergeWithStream());
     Throwable overallCause = null;
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         try {
             f.get();
         } catch (Throwable cause) {
             if (overallCause != null) {
                 overallCause = cause;
             }
         }
     }
     if (overallCause != null) {
         throw overallCause;
     }
 

Type Parameters:

T - The value type of the resulting Publisher.

Parameters:

mergeWith - the Publisher to merge in

Returns:

Publisher emits all items emitted by the passed Publisher and terminates when both this Completable and the passed Publisher terminate. If either terminates with an error then the error will be propagated to the return value.

See Also:

• ReactiveX merge operator.

mergeDelayError

public final Completable mergeDelayError(Completable other)

Merges this Completable with the other Completable, and delays error notification until all involved Completables terminate.

Use merge(Completable) if any error should immediately terminate the returned Completable.

This method provides a means to merge multiple asynchronous sources, delays throwing in the presence of any errors, and in sequential programming is similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     futures.add(e.submit(() -> resultOfCompletable(other));
     Throwable overallCause = null;
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         try {
             f.get();
         } catch (Throwable cause) {
             if (overallCause != null) {
                 overallCause = cause;
             }
         }
     }
     if (overallCause != null) {
         throw overallCause;
     }
 

Parameters:

other - Completable to merge.

Returns:

Completable that terminates after this Completable and other Completable. If all involved Completables terminate successfully then the return value will terminate successfully. If any Completable terminates in an error, then the return value will also terminate in an error.

mergeDelayError

public final Completable mergeDelayError(Completable... other)

Merges this Completable with the other Completables, and delays error notification until all involved Completables terminate.

Use merge(Completable...) if any error should immediately terminate the returned Completable.

This method provides a means to merge multiple asynchronous sources, delays throwing in the presence of any errors, and in sequential programming is similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     for (Completable c : other) {
         futures.add(e.submit(() -> resultOfCompletable(c));
     }
     Throwable overallCause = null;
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         try {
             f.get();
         } catch (Throwable cause) {
             if (overallCause != null) {
                 overallCause = cause;
             }
         }
     }
     if (overallCause != null) {
         throw overallCause;
     }
 

Parameters:

other - Completables to merge.

Returns:

Completable that terminates after this Completable and all other Completables. If all involved Completables terminate successfully then the return value will terminate successfully. If any Completable terminates in an error, then the return value will also terminate in an error.

mergeDelayError

public final Completable mergeDelayError(Iterable<? extends Completable> other)

Merges this Completable with the other Completables, and delays error notification until all involved Completables terminate.

Use merge(Iterable) if any error should immediately terminate the returned Completable.

This method provides a means to merge multiple asynchronous sources, delays throwing in the presence of any errors, and in sequential programming is similar to:

     ExecutorService e = ...;
     List<Future<Void>> futures = ...;
     futures.add(e.submit(() -> resultOfThisCompletable()));
     for (Completable c : other) {
         futures.add(e.submit(() -> resultOfCompletable(c));
     }
     Throwable overallCause = null;
     // This is an approximation, this operator does not provide any ordering guarantees for the results.
     for (Future<Void> future : futures) {
         try {
             f.get();
         } catch (Throwable cause) {
             if (overallCause != null) {
                 overallCause = cause;
             }
         }
     }
     if (overallCause != null) {
         throw overallCause;
     }
 

Parameters:

other - Completables to merge.

Returns:

Completable that terminates after this Completable and all other Completables. If all involved Completables terminate successfully then the return value will terminate successfully. If any Completable terminates in an error, then the return value will also terminate in an error.

retry

public final Completable retry(BiIntPredicate<Throwable> shouldRetry)

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

 This method may result in a StackOverflowError if too many consecutive calls are made. This can be
 avoided by trampolining the call stack onto an Executor. For example:
   retryWhen((i, cause) -> i % 10 == 0 ? executor.submit(() -> { }) : Completable.completed())
 

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

     public T execute() {
         return execute(0);
     }

     private T execute(int attempts) {
         try {
             resultOfThisCompletable();
         } catch (Throwable cause) {
             if (shouldRetry.apply(attempts + 1, cause)) {
                 return execute(attempts + 1);
             } else {
                 throw cause;
             }
         }
     }
 

Parameters:

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

Returns:

A Completable that completes with this Completable or re-subscribes if an error is emitted and if the passed BiPredicate returned true.

See Also:

• ReactiveX retry operator.

retryWhen

public final Completable retryWhen(BiIntFunction<Throwable,? extends Completable> retryWhen)

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

 This method may result in a StackOverflowError if too many consecutive calls are made. This can be
 avoided by trampolining the call stack onto an Executor. For example:
   retryWhen((i, cause) -> i % 10 == 0 ? executor.submit(() -> { }) : Completable.completed())
 

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 T execute() {
         return execute(0);
     }

     private T execute(int attempts) {
         try {
             resultOfThisCompletable();
         } catch (Throwable cause) {
             try {
                 shouldRetry.apply(attempts + 1, cause); // Either throws or completes normally
                 execute(attempts + 1);
             } catch (Throwable ignored) {
                 throw cause;
             }
         }
     }
 

Parameters:

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

Returns:

A Completable that completes with this Completable or re-subscribes if an error is emitted and Completable returned by BiFunction completes successfully.

See Also:

• ReactiveX retry operator.

repeat

public final Publisher<Void> repeat(IntPredicate shouldRepeat)

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

 This method may result in a StackOverflowError if too many consecutive calls are made. This can be
 avoided by trampolining the call stack onto an Executor. For example:
   repeatWhen(i -> i % 10 == 0 ? executor.submit(() -> { }) : Completable.completed())
 

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

     int i = 0;
     do {
         resultOfThisCompletable();
     } while (shouldRepeat.test(++i));
 

Parameters:

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

Returns:

A Publisher that emits the value returned by the passed Supplier everytime this Completable completes.

See Also:

• ReactiveX repeat operator.

repeatWhen

public final Publisher<Void> repeatWhen(IntFunction<? extends Completable> repeatWhen)

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

 This method may result in a StackOverflowError if too many consecutive calls are made. This can be
 avoided by trampolining the call stack onto an Executor. For example:
   repeatWhen(i -> i % 10 == 0 ? executor.submit(() -> { }) : Completable.completed())
 

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

     int i = 0;
     while (true) {
         resultOfThisCompletable();
         try {
             repeatWhen.apply(++i); // Either throws or completes normally
         } catch (Throwable cause) {
             break;
         }
     }
 

Parameters:

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

Returns:

A Completable that completes after all re-subscriptions completes.

See Also:

• ReactiveX retry operator.

cache

public final Completable cache()

Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

In sequential programming this is similar to the following:

     Void result = resultOfThisCompletable();
     List<Void> multiResults = ...; // simulating multiple Subscribers
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(result);
     }
     return multiResults;
 

Returns:

a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

See Also:

• ReactiveX cache operator
• cache(int)

cache

public final Completable cache(int minSubscribers)

Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

In sequential programming this is similar to the following:

     Void result = resultOfThisCompletable();
     List<Void> multiResults = ...; // simulating multiple Subscribers
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(result);
     }
     return multiResults;
 

Parameters:

minSubscribers - The upstream subscribe operation will not happen until after this many CompletableSource.Subscriber subscribe to the return value.

Returns:

a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

See Also:

• ReactiveX cache operator
• cache(int, boolean)

cache

public final Completable cache(int minSubscribers,
 boolean cancelUpstream)

Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

In sequential programming this is similar to the following:

     Void result = resultOfThisCompletable();
     List<Void> multiResults = ...; // simulating multiple Subscribers
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(result);
     }
     return multiResults;
 

Parameters:

minSubscribers - The upstream subscribe operation will not happen until after this many CompletableSource.Subscriber subscribe to the return value.

cancelUpstream - true if upstream should be cancelled when all downstream CompletableSource.Subscribers cancel. false means that cancel will not be propagated upstream even if all downstream CompletableSource.Subscribers cancel, and the upstream Subscription will stay valid until termination.

Returns:

a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

See Also:

• ReactiveX cache operator
• cache(int, boolean, Function)

cache

public final Completable cache(int minSubscribers,
 boolean cancelUpstream,
 Function<Throwable,Completable> terminalResubscribe)

Create a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

In sequential programming this is similar to the following:

     Void result = resultOfThisCompletable();
     List<Void> multiResults = ...; // simulating multiple Subscribers
     for (int i = 0; i < expectedSubscribers; ++i) {
         multiResults.add(result);
     }
     return multiResults;
 

Parameters:

minSubscribers - The upstream subscribe operation will not happen until after this many CompletableSource.Subscriber subscribe to the return value.

cancelUpstream - true if upstream should be cancelled when all downstream CompletableSource.Subscribers cancel. false means that cancel will not be propagated upstream even if all downstream CompletableSource.Subscribers cancel, and the upstream Subscription will stay valid until termination.

terminalResubscribe - A Function that is invoked when a terminal signal arrives from upstream, and returns a Completable whose termination resets the state of the returned Completable and allows for downstream resubscribing. The argument to this function is as follows:

• null if upstream terminates with CompletableSource.Subscriber.onComplete()
• otherwise the Throwable from CompletableSource.Subscriber.onError(Throwable)

Returns:

a Completable that subscribes a single time upstream but allows for multiple downstream CompletableSource.Subscribers. The terminal signal will be cached and delivered to each downstream CompletableSource.Subscriber.

See Also:

• ReactiveX cache operator

beforeOnSubscribe

public final Completable beforeOnSubscribe(Consumer<Cancellable> onSubscribe)

Invokes the onSubscribe Consumer argument before CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable.

Parameters:

onSubscribe - Invoked before CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable. MUST NOT throw.

Returns:

The new Completable.

beforeOnComplete

public final Completable beforeOnComplete(Runnable onComplete)

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

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

  resultOfThisCompletable();
  onComplete.run();
  nextOperation();
 

Parameters:

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

Returns:

The new Completable.

beforeOnError

public final Completable beforeOnError(Consumer<Throwable> onError)

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

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

  try {
    resultOfThisCompletable();
  } catch (Throwable cause) {
      onError.accept(cause);
      nextOperation(cause);
  }
 

Parameters:

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

Returns:

The new Completable.

beforeCancel

public final Completable beforeCancel(Runnable onCancel)

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

Parameters:

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

Returns:

The new Completable.

beforeFinally

public final Completable beforeFinally(Runnable doFinally)

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable.

  try {
      resultOfThisCompletable();
  } finally {
      doFinally.run();
      nextOperation(); // Maybe notifying of cancellation, or termination
  }
 

Parameters:

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable. MUST NOT throw.

Returns:

The new Completable.

See Also:

• ReactiveX do operator.

beforeFinally

public final Completable beforeFinally(TerminalSignalConsumer doFinally)

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable.

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

  try {
      resultOfThisCompletable();
  } 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 Completable, at most one method of this TerminalSignalConsumer will be invoked.

Returns:

The new Completable.

See Also:

• ReactiveX do operator.

beforeSubscriber

public final Completable beforeSubscriber(Supplier<? extends CompletableSource.Subscriber> subscriberSupplier)

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

Parameters:

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

Returns:

The new Completable.

afterOnSubscribe

public final Completable afterOnSubscribe(Consumer<Cancellable> onSubscribe)

Invokes the onSubscribe Consumer argument after CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable.

Parameters:

onSubscribe - Invoked after CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable. MUST NOT throw.

Returns:

The new Completable.

whenOnSubscribe

public final Completable whenOnSubscribe(Consumer<Cancellable> onSubscribe)

Invokes the onSubscribe Consumer argument when CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable.

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

Parameters:

onSubscribe - Invoked when CompletableSource.Subscriber.onSubscribe(Cancellable) is called for CompletableSource.Subscribers of the returned Completable. MUST NOT throw.

Returns:

The new Completable.

See Also:

• beforeOnSubscribe(Consumer)
• afterOnSubscribe(Consumer)

afterOnComplete

public final Completable afterOnComplete(Runnable onComplete)

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

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

  resultOfThisCompletable();
  nextOperation();
  onComplete.run();
 

Parameters:

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

Returns:

The new Completable.

afterOnError

public final Completable afterOnError(Consumer<Throwable> onError)

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

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

  try {
    resultOfThisCompletable();
  } catch (Throwable cause) {
      nextOperation(cause);
      onError.accept(cause);
  }
 

Parameters:

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

Returns:

The new Completable.

afterCancel

public final Completable afterCancel(Runnable onCancel)

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

Parameters:

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

Returns:

The new Completable.

afterFinally

public final Completable afterFinally(Runnable doFinally)

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable.

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

  try {
      resultOfThisCompletable();
  } finally {
      nextOperation(); // Maybe notifying of cancellation, or termination
      doFinally.run();
  }
 

Parameters:

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable. MUST NOT throw.

Returns:

The new Completable.

See Also:

• ReactiveX do operator.

afterFinally

public final Completable afterFinally(TerminalSignalConsumer doFinally)

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

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

for Subscriptions/CompletableSource.Subscribers of the returned Completable.

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

  try {
      resultOfThisCompletable();
  } 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 Completable, at most one method of this TerminalSignalConsumer will be invoked.

Returns:

The new Completable.

See Also:

• ReactiveX do operator.

afterSubscriber

public final Completable afterSubscriber(Supplier<? extends CompletableSource.Subscriber> subscriberSupplier)

Creates a new CompletableSource.Subscriber (via the subscriberSupplier argument) on each call to subscribe and invokes all the CompletableSource.Subscriber methods after the CompletableSource.Subscribers of the returned Completable.

Parameters:

subscriberSupplier - Creates a new CompletableSource.Subscriber on each call to subscribe and invokes all the CompletableSource.Subscriber methods after the CompletableSource.Subscribers of the returned Completable. CompletableSource.Subscriber methods MUST NOT throw.

Returns:

The new Completable.

whenSubscriber

public final Completable whenSubscriber(Supplier<? extends CompletableSource.Subscriber> subscriberSupplier)

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

Parameters:

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

Returns:

The new Completable.

liftSync

public final Completable liftSync(CompletableOperator 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 Completable which will wrap the CompletableSource.Subscriber using the provided operator argument before subscribing to this Completable.

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

The original -> modified "operator" MUST be "synchronous" in that it does not interact with the original CompletableSource.Subscriber from outside the modified CompletableSource.Subscriber or Cancellable 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(CompletableOperator).

Parameters:

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

Returns:

a Completable that when subscribed, the operator argument will be used to wrap the CompletableSource.Subscriber before subscribing to this Completable.

See Also:

• liftAsync(CompletableOperator)

liftAsync

public final Completable liftAsync(CompletableOperator 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 Completable which will wrap the CompletableSource.Subscriber using the provided operator argument before subscribing to this Completable.

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

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

• all of the CompletableSource.Subscriber invocations going "downstream" (i.e. from A to B above) MAY be offloaded via an Executor
• all of the Cancellable 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).

Parameters:

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

Returns:

a Completable that when subscribed, the operator argument will be used to wrap the CompletableSource.Subscriber before subscribing to this Completable.

See Also:

• liftSync(CompletableOperator)

publishOn

public final Completable publishOn(Executor executor)

Creates a new Completable that will use the passed Executor to invoke all CompletableSource.Subscriber methods. This method does not override preceding Executors, if any, specified for this Completable. Only subsequent operations, if any, added in this execution chain will use this Executor.

Note: unlike publishOn(io.servicetalk.concurrent.Executor, BooleanSupplier), current operator always enforces offloading to the passed Executor.

Parameters:

executor - Executor to use.

Returns:

A new Completable that will use the passed Executor to invoke all CompletableSource.Subscriber methods.

See Also:

• publishOn(io.servicetalk.concurrent.Executor, BooleanSupplier)

publishOn

public final Completable publishOn(Executor executor,
 BooleanSupplier shouldOffload)

Creates a new Completable that may use the passed Executor to invoke all CompletableSource.Subscriber methods. This method does not override preceding Executors, if any, specified for this Completable. Only subsequent operations, if any, added in this execution chain will use this Executor.

Note: unlike publishOn(io.servicetalk.concurrent.Executor), current operator may skip offloading to the passed Executor, depending on the result of the BooleanSupplier hint.

Parameters:

executor - Executor to use.

shouldOffload - Provides a hint whether offloading to the executor can be omitted or not. Offloading may still occur even if false is returned in order to preserve signal ordering.

Returns:

A new Completable that may use the passed Executor to invoke all CompletableSource.Subscriber methods.

See Also:

• publishOn(io.servicetalk.concurrent.Executor)

subscribeOn

public final Completable subscribeOn(Executor executor)

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

• All Cancellable methods.
• The handleSubscribe(CompletableSource.Subscriber) method.

This method does not override preceding Executors, if any, specified for this Completable. Only subsequent operations, if any, added in this execution chain will use this Executor.

Note: unlike subscribeOn(io.servicetalk.concurrent.Executor, BooleanSupplier), current operator always enforces offloading to the passed Executor.

Parameters:

executor - Executor to use.

Returns:

A new Completable that will use the passed Executor to invoke all methods of Cancellable and handleSubscribe(CompletableSource.Subscriber).

See Also:

• subscribeOn(io.servicetalk.concurrent.Executor, BooleanSupplier)

subscribeOn

public final Completable subscribeOn(Executor executor,
 BooleanSupplier shouldOffload)

Creates a new Completable that may use the passed Executor to invoke the following methods:

• All Cancellable methods.
• The handleSubscribe(CompletableSource.Subscriber) method.

This method does not override preceding Executors, if any, specified for this Completable. Only subsequent operations, if any, added in this execution chain will use this Executor.

Note: unlike subscribeOn(io.servicetalk.concurrent.Executor), current operator may skip offloading to = the passed Executor, depending on the result of the BooleanSupplier hint.

Parameters:

executor - Executor to use.

shouldOffload - Provides a hint whether offloading to the executor can be omitted or not. Offloading may still occur even if false is returned in order to preserve signal ordering.

Returns:

A new Completable that may use the passed Executor to invoke all methods of Cancellable and handleSubscribe(CompletableSource.Subscriber).

See Also:

• subscribeOn(io.servicetalk.concurrent.Executor)

shareContextOnSubscribe

public final Completable shareContextOnSubscribe()

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

This operator only impacts behavior if the returned Completable 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 Completable that will share the AsyncContext instead of making a copy when subscribed to.

setContextOnSubscribe

public final Completable setContextOnSubscribe(ContextMap context)

Specify the ContextMap to use for AsyncContext when the returned Completable is subscribed to.

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

Parameters:

context - The ContextMap to use for AsyncContext when subscribed.

Returns:

A Completable that will use the ContextMap for AsyncContext when subscribed.

ambWith

public final Completable ambWith(Completable other)

Creates a new Completable that terminates with the result (either success or error) of either this Completable or the passed other Completable, whichever terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from. After the first source terminates, only the non-terminated source will be cancelled.

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

      for (Future<T> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator will pick the first result from either of the futures.
          return ft.get();
      }
 

Parameters:

other - Completable to subscribe to and race with this Completable to propagate to the return value.

Returns:

A new Completable that terminates with the result (either success or error) of either this Completable or the passed other Completable, whichever terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from.

See Also:

• ReactiveX amb operator.

toPublisher

public final <T> Publisher<T> toPublisher()

Converts this Completable to a Publisher.

No PublisherSource.Subscriber.onNext(Object) signals will be delivered to the returned Publisher. Only terminal signals will be delivered. If you need more control you should consider using concat(Publisher).

Type Parameters:

T - The value type of the resulting Publisher.

Returns:

A Publisher that mirrors the terminal signal from this Completable.

toSingle

public final Single<Void> toSingle()

Converts this Completable to a Single.

Returns:

A Single that mirrors the terminal signal from this Completable.

toCompletionStage

public final CompletionStage<Void> toCompletionStage()

Converts this Completable to a CompletionStage.

Returns:

A CompletionStage that mirrors the terminal signal from this Completable.

toFuture

public final Future<Void> toFuture()

Converts this Completable to a Future.

Returns:

A Future that mirrors the terminal signal from this Completable.

subscribeInternal

protected final void subscribeInternal(CompletableSource.Subscriber subscriber)

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

Parameters:

subscriber - CompletableSource.Subscriber to subscribe for the result.

subscribe

public final Cancellable subscribe()

Subscribe to this Completable and log any CompletableSource.Subscriber.onError(Throwable).

Returns:

Cancellable used to invoke Cancellable.cancel() on the parameter of CompletableSource.Subscriber.onSubscribe(Cancellable) for this Completable.

subscribe

public final Cancellable subscribe(Runnable onComplete)

Subscribe to this Completable and log any CompletableSource.Subscriber.onError(Throwable). Passed Runnable is invoked when this Completable terminates successfully.

Parameters:

onComplete - Runnable to invoke when this Completable terminates successfully.

Returns:

Cancellable used to invoke Cancellable.cancel() on the parameter of CompletableSource.Subscriber.onSubscribe(Cancellable) for this Completable.

subscribe

public final Cancellable subscribe(Runnable onComplete,
 Consumer<? super Throwable> errorConsumer)

Subscribe to this Completable, invoke passed Runnable when this Completable terminates successfully or emit an error to Consumer when it fails.

Parameters:

onComplete - Runnable to invoke when this Completable terminates successfully.

errorConsumer - Consumer to accept the error when this Completable fails.

Returns:

Cancellable used to invoke Cancellable.cancel() on the parameter of CompletableSource.Subscriber.onSubscribe(Cancellable) for this Completable.

handleSubscribe

protected abstract void handleSubscribe(CompletableSource.Subscriber subscriber)

Handles a subscriber to this Completable.

This method is invoked internally by Completable for every call to the subscribeInternal(CompletableSource.Subscriber) method.

Parameters:

subscriber - the subscriber.

completed

public static Completable completed()

Creates a realized completed Completable.

Returns:

A new Completable.

fromRunnable

public static Completable fromRunnable(Runnable runnable)

Creates a Completable which when subscribed will invoke Runnable.run() on the passed Runnable and emit the value returned by that invocation from the returned Completable. Any error emitted by the Runnable will terminate the returned Completable with the same error.

Blocking inside Runnable.run() will in turn block the subscribe call to the returned Completable. If this behavior is undesirable then the returned Completable should be offloaded using subscribeOn(io.servicetalk.concurrent.Executor) which offloads the subscribe call.

Parameters:

runnable - Runnable which is invoked before completion.

Returns:

A new Completable.

fromCallable

public static Completable fromCallable(Callable<Void> callable)

Creates a Completable which when subscribed will invoke Callable.call() on the passed Callable and emit the value returned by that invocation from the returned Completable. Any error emitted by the Callable will terminate the returned Completable with the same error.

Blocking inside Callable.call() will in turn block the subscribe call to the returned Completable. If this behavior is undesirable then the returned Completable should be offloaded using subscribeOn(io.servicetalk.concurrent.Executor) which offloads the subscribe call.

Parameters:

callable - Callable which is invoked before completion.

Returns:

A new Completable.

failed

public static Completable failed(Throwable cause)

Creates a realized failed Completable.

Parameters:

cause - error that the returned Completable completes with.

Returns:

A new Completable.

never

public static Completable never()

Creates a Completable that never terminates.

Returns:

A new Completable.

defer

public static Completable defer(Supplier<? extends Completable> completableSupplier)

Defer creation of a Completable till it is subscribed to.

Parameters:

completableSupplier - Supplier to create a new Completable for every call to subscribeInternal(CompletableSource.Subscriber) to the returned Completable.

Returns:

A new Completable that creates a new Completable using completableFactory for every call to subscribeInternal(CompletableSource.Subscriber) and forwards the termination signal from the newly created Completable to its CompletableSource.Subscriber.

fromFuture

public static Completable fromFuture(Future<?> future)

Convert from a Future to a Completable via Future.get().

Note that because Future only presents blocking APIs to extract the result, so the process of getting the results will block. The caller of subscribeInternal(CompletableSource.Subscriber) is responsible for offloading if necessary, and also offloading if Cancellable.cancel() will be called if this operation may block.

To apply a timeout see timeout(long, TimeUnit) and related methods.

Parameters:

future - The Future to convert.

Returns:

A Completable that derives results from Future.

See Also:

• timeout(long, TimeUnit)

fromStage

public static Completable fromStage(CompletionStage<?> stage)

Convert from a CompletionStage to a Completable.

A best effort is made to propagate Cancellable.cancel() to the CompletionStage. Cancellation for CompletionStage implementations will result in exceptional completion and invoke user callbacks. If there is any blocking code involved in the cancellation process (including invoking user callbacks) you should investigate if using an Executor is appropriate.

Parameters:

stage - The CompletionStage to convert.

Returns:

A Completable that derives results from CompletionStage.

mergeAll

public static Completable mergeAll(Iterable<? extends Completable> completables)

Returns a Completable that terminates when all the passed Completable terminate.

This will actively subscribe to a default number of Completables concurrently, in order to alter the defaults, mergeAll(Iterable, int).

If any of the Completables terminate with an error, returned Completable will immediately terminate with that error. In such a case, any in-progress Completables will be cancelled. In order to delay error termination use mergeAllDelayError(Iterable).

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

      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
          ft.get();
      }
 

Parameters:

completables - Iterable of Completables, results of which are to be collected.

Returns:

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

mergeAll

public static Completable mergeAll(Completable... completables)

Returns a Completable that terminates when all the passed Completable terminate.

This will actively subscribe to a default number of Completables concurrently, in order to alter the defaults, mergeAll(int, Completable...) should be used.

If any of the Completables terminate with an error, returned Completable will immediately terminate with that error. In such a case, any in-progress Completables will be cancelled. In order to delay error termination use mergeAllDelayError(Completable...).

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

      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
          ft.get();
      }
 

Parameters:

completables - Completables, results of which are to be collected.

Returns:

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

mergeAll

public static Completable mergeAll(Iterable<? extends Completable> completables,
 int maxConcurrency)

Returns a Completable that terminates when all the passed Completable terminate.

If any of the Completables terminate with an error, returned Completable will immediately terminate with that error. In such a case, any in-progress Completables will be cancelled. In order to delay error termination use mergeAllDelayError(Iterable, int).

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

      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
          ft.get();
      }
 

Parameters:

completables - Iterable of Completables, results of which are to be collected.

maxConcurrency - Maximum number of Completables that will be active at any point in time.

Returns:

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

mergeAll

public static Completable mergeAll(int maxConcurrency,
 Completable... completables)

Returns a Completable that terminates when all the passed Completable terminate.

If any of the Completables terminate with an error, returned Completable will immediately terminate with that error. In such a case, any in-progress Completables will be cancelled. In order to delay error termination use mergeAllDelayError(int, Completable...).

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

      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
          ft.get();
      }
 

Parameters:

maxConcurrency - Maximum number of Completables that will be active at any point in time.

completables - Completables, results of which are to be collected.

Returns:

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

mergeAllDelayError

public static Completable mergeAllDelayError(Iterable<? extends Completable> completables)

Returns a Completable that terminates when all the passed Completable terminate.

This will actively subscribe to a default number of Completables concurrently, in order to alter the defaults, mergeAllDelayError(Iterable, int) should be used.

If any of the Completables terminate with an error, returned Completable will wait for termination till all the other Completables have been subscribed and terminated. If it is expected for the returned Completable to terminate on the first failing Completable, mergeAll(Iterable) should be used.

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

      List<Throwable> errors = ...;  // assume this is thread safe
      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
             try {
                 ft.get();
             } catch(Throwable t) {
                errors.add(t);
             }
      }
     if (errors.isEmpty()) {
         return;
     }
     createAndThrowACompositeException(errors);
 

Parameters:

completables - Iterable of Completables, results of which are to be collected.

Returns:

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

mergeAllDelayError

public static Completable mergeAllDelayError(Completable... completables)

Returns a Completable that terminates when all the passed Completable terminate.

This will actively subscribe to a limited number of Singles concurrently, in order to alter the defaults, mergeAll(int, Completable...) should be used.

If any of the Singles terminate with an error, returned Single will wait for termination till all the other Singles have been subscribed and terminated. If it is expected for the returned Single to terminate on the first failing Single, mergeAll(Completable...) should be used.

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

      List<Throwable> errors = ...;  // assume this is thread safe
      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
             try {
                 ft.get();
             } catch(Throwable t) {
                errors.add(t);
             }
      }
     if (errors.isEmpty()) {
         return;
     }
     createAndThrowACompositeException(errors);
 

Parameters:

completables - Completables, results of which are to be collected.

Returns:

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

mergeAllDelayError

public static Completable mergeAllDelayError(Iterable<? extends Completable> completables,
 int maxConcurrency)

Returns a Completable that terminates when all the passed Completable terminate.

If any of the Singles terminate with an error, returned Single will wait for termination till all the other Singles have been subscribed and terminated. If it is expected for the returned Single to terminate on the first failing Single, mergeAll(Iterable, int) should be used.

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

      List<Throwable> errors = ...;  // assume this is thread safe
      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
             try {
                 ft.get();
             } catch(Throwable t) {
                errors.add(t);
             }
      }
     if (errors.isEmpty()) {
         return;
     }
     createAndThrowACompositeException(errors);
 

Parameters:

completables - Iterable of Completables, results of which are to be collected.

maxConcurrency - Maximum number of Completables that will be active at any point in time.

Returns:

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

mergeAllDelayError

public static Completable mergeAllDelayError(int maxConcurrency,
 Completable... completables)

Returns a Completable that terminates when all the passed Completable terminate.

If any of the Singles terminate with an error, returned Single will wait for termination till all the other Singles have been subscribed and terminated. If it is expected for the returned Single to terminate on the first failing Single, mergeAll(Iterable, int) should be used.

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

      List<Throwable> errors = ...;  // assume this is thread safe
      for (Future<Void> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator does not provide any ordering guarantees for the results.
             try {
                 ft.get();
             } catch(Throwable t) {
                errors.add(t);
             }
      }
     if (errors.isEmpty()) {
         return;
     }
     createAndThrowACompositeException(errors);
 

Parameters:

maxConcurrency - Maximum number of Completables that will be active at any point in time.

completables - Completables, results of which are to be collected.

Returns:

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

amb

public static Completable amb(Completable... completables)

Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from. After the first source terminates, only the non-terminated sources will be cancelled.

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

      for (Future<T> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator will pick the first result from any of the futures.
          return ft.get();
      }
 

Parameters:

completables - Completables to subscribe to and race to propagate to the return value.

Returns:

A new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from.

See Also:

• ReactiveX amb operator.

amb

public static Completable amb(Iterable<Completable> completables)

Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. After the first source terminates, only the non-terminated sources will be cancelled.

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

      for (Future<T> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator will pick the first result from any of the futures.
          return ft.get();
      }
 

Parameters:

completables - Completables to subscribe to and race to propagate to the return value.

Returns:

A new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from.

See Also:

• ReactiveX amb operator.

anyOf

public static Completable anyOf(Completable... completables)

Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from. After the first source terminates, only the non-terminated sources will be cancelled.

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

      for (Future<T> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator will pick the first result from any of the futures.
          return ft.get();
      }
 

Parameters:

completables - Completables which to subscribe to and race to propagate to the return value.

Returns:

A new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first.

See Also:

• ReactiveX amb operator.

anyOf

public static Completable anyOf(Iterable<Completable> completables)

Creates a new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. Therefore, the result is said to be ambiguous relative to which source it originated from. After the first source terminates, only the non-terminated sources will be cancelled.

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

      for (Future<T> ft: futures) { // Provided Futures (analogous to the Completables here)
          // This is an approximation, this operator will pick the first result from any of the futures.
          return ft.get();
      }
 

Parameters:

completables - Completables which to subscribe to and race to propagate to the return value.

Returns:

A new Completable that terminates with the result (either success or error) of whichever amongst the passed completables that terminates first. that result.

See Also:

• ReactiveX amb operator.