java.lang.Object
- io.servicetalk.concurrent.api.Completable

Direct Known Subclasses:

LegacyTestCompletable, RunnableCompletable, SubscribableCompletable, TestCompletable
```
public abstract class Completable
extends java.lang.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

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`Completable`	`afterCancel(java.lang.Runnable onCancel)`	Invokes the `onCancel` `Runnable` argument after `Cancellable.cancel()` is called for Subscriptions of the returned `Completable`.
`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.Subscriber`s of the returned `Completable`.
`Completable`	`afterFinally(java.lang.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.Subscriber`s of the returned `Completable`.
`Completable`	`afterOnComplete(java.lang.Runnable onComplete)`	Invokes the `onComplete` `Runnable` argument after `CompletableSource.Subscriber.onComplete()` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`afterOnError(java.util.function.Consumer<java.lang.Throwable> onError)`	Invokes the `onError` `Consumer` argument after `CompletableSource.Subscriber.onError(Throwable)` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`afterOnSubscribe(java.util.function.Consumer<Cancellable> onSubscribe)`	Invokes the `onSubscribe` `Consumer` argument after `CompletableSource.Subscriber.onSubscribe(Cancellable)` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`afterSubscriber(java.util.function.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.Subscriber`s 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(java.lang.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.
`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(java.lang.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.
`Completable`	`beforeCancel(java.lang.Runnable onCancel)`	Invokes the `onCancel` `Runnable` argument before `Cancellable.cancel()` is called for Subscriptions of the returned `Completable`.
`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.Subscriber`s of the returned `Completable`.
`Completable`	`beforeFinally(java.lang.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.Subscriber`s of the returned `Completable`.
`Completable`	`beforeOnComplete(java.lang.Runnable onComplete)`	Invokes the `onComplete` `Runnable` argument before `CompletableSource.Subscriber.onComplete()` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`beforeOnError(java.util.function.Consumer<java.lang.Throwable> onError)`	Invokes the `onError` `Consumer` argument before `CompletableSource.Subscriber.onError(Throwable)` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`beforeOnSubscribe(java.util.function.Consumer<Cancellable> onSubscribe)`	Invokes the `onSubscribe` `Consumer` argument before `CompletableSource.Subscriber.onSubscribe(Cancellable)` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`beforeSubscriber(java.util.function.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.Subscriber`s of the returned `Completable`.
`static Completable`	`completed()`	Creates a realized completed `Completable`.
`Completable`	`concat(Completable next)`	Once this `Completable` is terminated successfully, subscribe to `next` `Completable` and propagate its terminal signal to the returned `Completable`.
`<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`.
`<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(java.util.function.Supplier<? extends Completable> completableSupplier)`	Defer creation of a `Completable` till it is subscribed to.
`static Completable`	`failed(java.lang.Throwable cause)`	Creates a realized failed `Completable`.
`static Completable`	`fromFuture(java.util.concurrent.Future<?> future)`	Convert from a `Future` to a `Completable` via `Future.get()`.
`static Completable`	`fromRunnable(java.lang.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(java.util.concurrent.CompletionStage<?> stage)`	Convert from a `CompletionStage` to a `Completable`.
`protected abstract void`	`handleSubscribe(CompletableSource.Subscriber subscriber)`	Handles a subscriber to this `Completable`.
`Completable`	`idleTimeout(long duration, java.util.concurrent.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.
`Completable`	`idleTimeout(long duration, java.util.concurrent.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.
`Completable`	`idleTimeout(java.time.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.
`Completable`	`idleTimeout(java.time.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.
`Completable`	`liftAsync(CompletableOperator operator)`	This method requires advanced knowledge of building operators.
`Completable`	`liftSync(CompletableOperator operator)`	This method requires advanced knowledge of building operators.
`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.
`Completable`	`merge(Completable... other)`	Merges this `Completable` with the `other` `Completable`s so that the resulting `Completable` terminates successfully when all of these complete or any one terminates with an error.
`<T> Publisher<T>`	`merge(Publisher<? extends T> mergeWith)`	Merges the passed `Publisher` with this `Completable`.
`Completable`	`merge(java.lang.Iterable<? extends Completable> other)`	Merges this `Completable` with the `other` `Completable`s so that the resulting `Completable` terminates successfully when all of these complete or terminates with an error when any one terminates with an error.
`static Completable`	`mergeAll(int maxConcurrency, Completable... completables)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAll(Completable... completables)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAll(java.lang.Iterable<? extends Completable> completables)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAll(java.lang.Iterable<? extends Completable> completables, int maxConcurrency)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAllDelayError(int maxConcurrency, Completable... completables)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAllDelayError(Completable... completables)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAllDelayError(java.lang.Iterable<? extends Completable> completables)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`static Completable`	`mergeAllDelayError(java.lang.Iterable<? extends Completable> completables, int maxConcurrency)`	Returns a `Completable` that terminates when all the passed `Completable` terminate.
`Completable`	`mergeDelayError(Completable other)`	Merges this `Completable` with the `other` `Completable`, and delays error notification until all involved `Completable`s terminate.
`Completable`	`mergeDelayError(Completable... other)`	Merges this `Completable` with the `other` `Completable`s, and delays error notification until all involved `Completable`s terminate.
`Completable`	`mergeDelayError(java.lang.Iterable<? extends Completable> other)`	Merges this `Completable` with the `other` `Completable`s, and delays error notification until all involved `Completable`s terminate.
`static Completable`	`never()`	Creates a `Completable` that never terminates.
`Completable`	`onErrorResume(java.util.function.Function<java.lang.Throwable,? extends Completable> nextFactory)`	Recover from any error emitted by this `Completable` by using another `Completable` provided by the passed `nextFactory`.
`Completable`	`publishAndSubscribeOn(Executor executor)`	Creates a new `Completable` that will use the passed `Executor` to invoke the following methods: All `CompletableSource.Subscriber` methods. All `Cancellable` methods. The `handleSubscribe(CompletableSource.Subscriber)` method. This method does not override preceding `Executor`s, if any, specified for `this` `Completable`.
`Completable`	`publishAndSubscribeOnOverride(Executor executor)`	Creates a new `Completable` that will use the passed `Executor` to invoke the following methods: All `CompletableSource.Subscriber` methods. All `Cancellable` methods. The `handleSubscribe(CompletableSource.Subscriber)` method. This method overrides preceding `Executor`s, if any, specified for `this` `Completable`.
`Completable`	`publishOn(Executor executor)`	Creates a new `Completable` that will use the passed `Executor` to invoke all `CompletableSource.Subscriber` methods.
`Completable`	`publishOnOverride(Executor executor)`	Creates a new `Completable` that will use the passed `Executor` to invoke all `CompletableSource.Subscriber` methods.
`Publisher<java.lang.Void>`	`repeat(java.util.function.IntPredicate shouldRepeat)`	Re-subscribes to this `Completable` when it completes and the passed `IntPredicate` returns `true`.
`Publisher<java.lang.Void>`	`repeatWhen(java.util.function.IntFunction<? extends Completable> repeatWhen)`	Re-subscribes to this `Completable` when it completes and the `Completable` returned by the supplied `IntFunction` completes successfully.
`Completable`	`retry(BiIntPredicate<java.lang.Throwable> shouldRetry)`	Re-subscribes to this `Completable` if an error is emitted and the passed `BiIntPredicate` returns `true`.
`Completable`	`retryWhen(BiIntFunction<java.lang.Throwable,? extends Completable> retryWhen)`	Re-subscribes to this `Completable` if an error is emitted and the `Completable` returned by the supplied `BiIntFunction` completes successfully.
`Cancellable`	`subscribe()`	Subscribe to this `Completable` and log any `CompletableSource.Subscriber.onError(Throwable)`.
`Cancellable`	`subscribe(java.lang.Runnable onComplete)`	Subscribe to this `Completable` and log any `CompletableSource.Subscriber.onError(Throwable)`.
`protected void`	`subscribeInternal(CompletableSource.Subscriber subscriber)`	A internal subscribe method similar to `CompletableSource.subscribe(Subscriber)` which can be used by different implementations to subscribe.
`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 `Executor`s, if any, specified for `this` `Completable`.
`Completable`	`subscribeOnOverride(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 overrides preceding `Executor`s, if any, specified for `this` `Completable`.
`Completable`	`subscribeShareContext()`	Signifies that when the returned `Completable` is subscribed to, the `AsyncContext` will be shared instead of making a `copy`.
`java.util.concurrent.CompletionStage<java.lang.Void>`	`toCompletionStage()`	Converts this `Completable` to a `CompletionStage`.
`java.util.concurrent.Future<java.lang.Void>`	`toFuture()`	Converts this `Completable` to a `Future`.
`<T> Publisher<T>`	`toPublisher()`	Converts this `Completable` to a `Publisher`.
`Single<java.lang.Void>`	`toSingle()`	Converts this `Completable` to a `Single`.
`Completable`	`whenCancel(java.lang.Runnable onCancel)`	Invokes the `onCancel` `Runnable` argument when `Cancellable.cancel()` is called for Subscriptions of the returned `Completable`.
`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.Subscriber`s of the returned `Completable`.
`Completable`	`whenFinally(java.lang.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.Subscriber`s of the returned `Completable`.
`Completable`	`whenOnComplete(java.lang.Runnable onComplete)`	Invokes the `onComplete` `Runnable` argument when `CompletableSource.Subscriber.onComplete()` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`whenOnError(java.util.function.Consumer<java.lang.Throwable> onError)`	Invokes the `onError` `Consumer` argument when `CompletableSource.Subscriber.onError(Throwable)` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`whenOnSubscribe(java.util.function.Consumer<Cancellable> onSubscribe)`	Invokes the `onSubscribe` `Consumer` argument when `CompletableSource.Subscriber.onSubscribe(Cancellable)` is called for `CompletableSource.Subscriber`s of the returned `Completable`.
`Completable`	`whenSubscriber(java.util.function.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.Subscriber`s of the returned `Publisher`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Completable
```
protected Completable()
```
    New instance.
- Method Detail
  - onErrorResume
```
public final Completable onErrorResume(java.util.function.Function<java.lang.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.
  - whenOnComplete
```
public final Completable whenOnComplete(java.lang.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(java.util.function.Consumer<java.lang.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(java.lang.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(java.lang.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)
  - idleTimeout
```
public final Completable idleTimeout(long duration,
                                     java.util.concurrent.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.
  - idleTimeout
```
public final Completable idleTimeout(long duration,
                                     java.util.concurrent.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.
  - idleTimeout
```
public final Completable idleTimeout(java.time.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.
  - idleTimeout
```
public final Completable idleTimeout(java.time.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 <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(java.lang.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 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(java.lang.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<java.lang.Throwable> shouldRetry)
```
    Re-subscribes to this Completable 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 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<java.lang.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 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<java.lang.Void> repeat(java.util.function.IntPredicate shouldRepeat)
```
    Re-subscribes to this Completable 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:
    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<java.lang.Void> repeatWhen(java.util.function.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 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.
  - beforeOnSubscribe
```
public final Completable beforeOnSubscribe(java.util.function.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(java.lang.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(java.util.function.Consumer<java.lang.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(java.lang.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(java.lang.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(java.util.function.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(java.util.function.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(java.util.function.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(java.lang.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(java.util.function.Consumer<java.lang.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(java.lang.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(java.lang.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(java.util.function.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(java.util.function.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. If such an override is required, publishOnOverride(Executor) can be used.
    
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Completable that will use the passed Executor to invoke all methods on the CompletableSource.Subscriber.
  - publishOnOverride
```
public final Completable publishOnOverride(Executor executor)
```
    Creates a new Completable that will use the passed Executor to invoke all CompletableSource.Subscriber methods. This method overrides preceding Executors, if any, specified for this Completable. 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 Completable that will use the passed Executor to invoke all methods of CompletableSource.Subscriber, Cancellable and handleSubscribe(CompletableSource.Subscriber) both for the returned Completable as well as this Completable.
  - 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. If such an override is required, subscribeOnOverride(Executor) can be used.
    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).
  - subscribeOnOverride
```
public final Completable subscribeOnOverride(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 overrides preceding Executors, if any, specified for this Completable. 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 Completable that will use the passed Executor to invoke all methods of Cancellable and handleSubscribe(CompletableSource.Subscriber) both for the returned Completable as well as this Completable.
  - publishAndSubscribeOn
```
public final Completable publishAndSubscribeOn(Executor executor)
```
    Creates a new Completable that will use the passed Executor to invoke the following methods:
    
    All CompletableSource.Subscriber 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. If such an override is required, publishAndSubscribeOnOverride(Executor) can be used.
    Parameters:
    
    executor - Executor to use.
    
    Returns:
    
    A new Completable that will use the passed Executor to invoke all methods CompletableSource.Subscriber, Cancellable and handleSubscribe(CompletableSource.Subscriber).
  - publishAndSubscribeOnOverride
```
public final Completable publishAndSubscribeOnOverride(Executor executor)
```
    Creates a new Completable that will use the passed Executor to invoke the following methods:
    
    All CompletableSource.Subscriber methods.
    
    All Cancellable methods.
    
    The handleSubscribe(CompletableSource.Subscriber) method.
    
    This method overrides preceding Executors, if any, specified for this Completable. 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 Completable that will use the passed Executor to invoke all methods of CompletableSource.Subscriber, Cancellable and handleSubscribe(CompletableSource.Subscriber) both for the returned Completable as well as this Completable.
  - subscribeShareContext
```
public final Completable subscribeShareContext()
```
    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.
  - 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.
    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 with which the result of this Completable is to be ambiguated.
    
    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.
    
    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<java.lang.Void> toSingle()
```
    Converts this Completable to a Single.
    
    Returns:
    
    A Single that mirrors the terminal signal from this Completable.
  - toCompletionStage
```
public final java.util.concurrent.CompletionStage<java.lang.Void> toCompletionStage()
```
    Converts this Completable to a CompletionStage.
    
    Returns:
    
    A CompletionStage that mirrors the terminal signal from this Completable.
  - toFuture
```
public final java.util.concurrent.Future<java.lang.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(java.lang.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.
  - 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(java.lang.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 one of the operators that offloads the subscribe call (eg: subscribeOn(Executor), publishAndSubscribeOn(Executor)).
    
    Parameters:
    
    runnable - Runnable which is invoked before completion.
    
    Returns:
    
    A new Completable.
  - failed
```
public static Completable failed(java.lang.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(java.util.function.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(java.util.concurrent.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 idleTimeout(long, TimeUnit) and related methods.
    
    Parameters:
    
    future - The Future to convert.
    
    Returns:
    
    A Completable that derives results from Future.
    
    See Also:
    
    idleTimeout(long, TimeUnit)
  - fromStage
```
public static Completable fromStage(java.util.concurrent.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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.
    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 the result of which are to be ambiguated.
    
    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.
  - amb
```
public static Completable amb(java.lang.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.
    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 the result of which are to be ambiguated.
    
    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.
  - 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.
    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 the result of which are to be ambiguated.
    
    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(java.lang.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.
    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 the result of which are to be ambiguated.
    
    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.

Class Completable

How to subscribe?

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Completable

Method Detail

onErrorResume

whenOnComplete

whenOnError

whenFinally

whenFinally

whenCancel

idleTimeout

idleTimeout

idleTimeout

idleTimeout

concat

concat

concat

merge

merge

merge

merge

mergeDelayError

mergeDelayError

mergeDelayError

retry

retryWhen

repeat

repeatWhen

beforeOnSubscribe

beforeOnComplete

beforeOnError

beforeCancel

beforeFinally

beforeFinally

beforeSubscriber

afterOnSubscribe

whenOnSubscribe

afterOnComplete

afterOnError

afterCancel

afterFinally

afterFinally

afterSubscriber

whenSubscriber

liftSync

liftAsync

publishOn

publishOnOverride

subscribeOn

subscribeOnOverride

publishAndSubscribeOn

publishAndSubscribeOnOverride

subscribeShareContext

ambWith

toPublisher

toSingle

toCompletionStage

toFuture

subscribeInternal

subscribe

subscribe

handleSubscribe

completed

fromRunnable

failed

never

defer

fromFuture

fromStage

mergeAll

mergeAll

mergeAll

mergeAll

mergeAllDelayError

mergeAllDelayError

mergeAllDelayError