Completable (rxjava2-backport 2.0.0-RC2 API)

java.lang.Object
- hu.akarnokd.rxjava2.Completable

```
public class Completable
extends java.lang.Object
```
Represents a deferred computation without any value but only indication for completion or exception. The class follows a similar event pattern as Reactive-Streams: onSubscribe (onError|onComplete)?

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Completable.CompletableOnSubscribe` Callback used for building deferred computations that takes a CompletableSubscriber.
`static interface`	`Completable.CompletableOperator` Convenience interface and callback used by the lift operator that given a child CompletableSubscriber, return a parent CompletableSubscriber that does any kind of lifecycle-related transformations.
`static interface`	`Completable.CompletableSubscriber` Represents the subscription API callbacks when subscribing to a Completable instance.
`static interface`	`Completable.CompletableTransformer` Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Completable(Completable.CompletableOnSubscribe onSubscribe)` Constructs a Completable instance with the given onSubscribe callback.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static Completable`	`amb(Completable... sources)` Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and cancels all other Completables.
`static Completable`	`amb(java.lang.Iterable<? extends Completable> sources)` Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and cancels all other Completables.
`Completable`	`ambWith(Completable other)` Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
`void`	`await()` Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.
`boolean`	`await(long timeout, java.util.concurrent.TimeUnit unit)` Subscribes to and awaits the termination of this Completable instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.
`static Completable`	`complete()` Returns a Completable instance that completes immediately when subscribed to.
`Completable`	`compose(Completable.CompletableTransformer transformer)` Calls the given transformer function with this instance and returns the function's resulting Completable.
`static Completable`	`concat(Completable... sources)` Returns a Completable which completes only when all sources complete, one after another.
`static Completable`	`concat(java.lang.Iterable<? extends Completable> sources)` Returns a Completable which completes only when all sources complete, one after another.
`static Completable`	`concat(Observable<? extends Completable> sources)` Returns a Completable which completes only when all sources complete, one after another.
`static Completable`	`concat(Observable<? extends Completable> sources, int prefetch)` Returns a Completable which completes only when all sources complete, one after another.
`Completable`	`concatWith(Completable other)` Concatenates this Completable with another Completable.
`static Completable`	`create(Completable.CompletableOnSubscribe onSubscribe)` Constructs a Completable instance by wrapping the given onSubscribe callback.
`static Completable`	`defer(Supplier<? extends Completable> completableSupplier)` Defers the subscription to a Completable instance returned by a supplier.
`Completable`	`delay(long delay, java.util.concurrent.TimeUnit unit)` Returns a Completable which delays the emission of the completion event by the given time.
`Completable`	`delay(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler)` Returns a Completable which delays the emission of the completion event by the given time while running on the specified scheduler.
`Completable`	`delay(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler, boolean delayError)` Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified scheduler.
`Completable`	`doOnComplete(java.lang.Runnable onComplete)` Returns a Completable which calls the given onComplete callback if this Completable completes.
`Completable`	`doOnDispose(java.lang.Runnable onDispose)` Returns a Completable which calls the giveon onDispose callback if the child subscriber cancels the subscription.
`Completable`	`doOnError(Consumer<? super java.lang.Throwable> onError)` Returns a Completable which calls the given onError callback if this Completable emits an error.
`protected Completable`	`doOnLifecycle(Consumer<? super Disposable> onSubscribe, Consumer<? super java.lang.Throwable> onError, java.lang.Runnable onComplete, java.lang.Runnable onAfterComplete, java.lang.Runnable onDisposed)` Returns a Completable instance that calls the various callbacks on the specific lifecycle events.
`Completable`	`doOnSubscribe(Consumer<? super Disposable> onSubscribe)` Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
`Completable`	`doOnTerminate(java.lang.Runnable onTerminate)` Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception
`Completable`	`endWith(Completable other)` Returns a completable that first runs this Completable and then the other completable.
`<T> NbpObservable<T>`	`endWith(NbpObservable<T> next)` Returns an NbpObservable that first runs this Completable instance and resumes with the given next Observable.
`<T> Observable<T>`	`endWith(Observable<T> next)` Returns an Observable that first runs this Completable instance and resumes with the given next Observable.
`static Completable`	`error(Supplier<? extends java.lang.Throwable> errorSupplier)` Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
`static Completable`	`error(java.lang.Throwable error)` Creates a Completable instance that emits the given Throwable exception to subscribers.
`Completable`	`finallyDo(java.lang.Runnable onAfterComplete)` Returns a Completable instace that calls the given onAfterComplete callback after this Completable completes normally.
`static Completable`	`fromCallable(java.util.concurrent.Callable<?> callable)` Returns a Completable which when subscribed, executes the callable function, ignores its normal result and emits onError or onCompleted only.
`static <T> Completable`	`fromFlowable(Observable<T> flowable)` Returns a Completable instance that subscribes to the given flowable, ignores all values and emits only the terminal event.
`static <T> Completable`	`fromNbpObservable(NbpObservable<T> observable)` Returns a Completable instance that subscribes to the given NbpObservable, ignores all values and emits only the terminal event.
`static Completable`	`fromRunnable(java.lang.Runnable run)` Returns a Completable instance that runs the given Runnable for each subscriber and emits either an unchecked exception or simply completes.
`static <T> Completable`	`fromSingle(Single<T> single)` Returns a Completable instance that when subscribed to, subscribes to the Single instance and emits a completion event if the single emits onSuccess or forwards any onError events.
`java.lang.Throwable`	`get()` Subscribes to this Completable instance and blocks until it terminates, then returns null or the emitted exception if any.
`java.lang.Throwable`	`get(long timeout, java.util.concurrent.TimeUnit unit)` Subscribes to this Completable instance and blocks until it terminates or the specified timeout ellapses, then returns null for normal termination or the emitted exception if any.
`Completable`	`lift(Completable.CompletableOperator onLift)` Lifts a CompletableSubscriber transformation into the chain of Completables.
`static Completable`	`merge(Completable... sources)` Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
`static Completable`	`merge(java.lang.Iterable<? extends Completable> sources)` Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
`static Completable`	`merge(Observable<? extends Completable> sources)` Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
`static Completable`	`merge(Observable<? extends Completable> sources, int maxConcurrency)` Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source Completables complete or one of them emits an error.
`protected static Completable`	`merge0(Observable<? extends Completable> sources, int maxConcurrency, boolean delayErrors)` Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source Completables terminate in one way or another, combining any exceptions thrown by either the sources Observable or the inner Completable instances.
`static Completable`	`mergeDelayError(Completable... sources)` Returns a Completable that subscribes to all Completables in the source array and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`static Completable`	`mergeDelayError(java.lang.Iterable<? extends Completable> sources)` Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`static Completable`	`mergeDelayError(Observable<? extends Completable> sources)` Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`static Completable`	`mergeDelayError(Observable<? extends Completable> sources, int maxConcurrency)` Returns a Completable that subscribes to a limited number of inner Completables at once in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
`Completable`	`mergeWith(Completable other)` Returns a Completable which subscribes to this and the other Completable and completes when both of them complete or one emits an error.
`static Completable`	`never()` Returns a Completable that never calls onError or onComplete.
`Completable`	`observeOn(Scheduler scheduler)` Returns a Completable which emits the terminal events from the thread of the specified scheduler.
`Completable`	`onErrorComplete()` Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the throwable.
`Completable`	`onErrorComplete(Predicate<? super java.lang.Throwable> predicate)` Returns a Completable instance that if this Completable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
`Completable`	`onErrorResumeNext(Function<? super java.lang.Throwable,? extends Completable> errorMapper)` Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper function that returns another Completable instance for it and resumes the execution with it.
`Completable`	`repeat()` Returns a Completable that repeatedly subscribes to this Completable until cancelled.
`Completable`	`repeat(long times)` Returns a Completable that subscribes repeatedly at most the given times to this Completable.
`Completable`	`repeatUntil(BooleanSupplier stop)` Returns a Completable that repeatedly subscribes to this Completable so long as the given stop supplier returns false.
`Completable`	`repeatWhen(Function<? super Observable<java.lang.Object>,? extends org.reactivestreams.Publisher<java.lang.Object>> handler)` Returns a Completable instance that repeats when the Publisher returned by the handler emits an item or completes when this Publisher emits a completed event.
`Completable`	`retry()` Returns a Completable that retries this Completable as long as it emits an onError event.
`Completable`	`retry(BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)` Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.
`Completable`	`retry(long times)` Returns a Completable that when this Completable emits an error, retries at most the given number of times before giving up and emitting the last error.
`Completable`	`retry(Predicate<? super java.lang.Throwable> predicate)` Returns a Completable that when this Completable emits an error, calls the given predicate with the latest exception to decide whether to resubscribe to this or not.
`Completable`	`retryWhen(Function<? super Observable<? extends java.lang.Throwable>,? extends org.reactivestreams.Publisher<java.lang.Object>> handler)` Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through an Observable and the Publisher should return a value indicating a retry in response or a terminal event indicating a termination.
`Completable`	`startWith(Completable other)` Returns a Completable which first runs the other Completable then this completable if the other completed normally.
`<T> NbpObservable<T>`	`startWith(NbpObservable<T> other)` Returns an NbpObservable which first delivers the events of the other NbpObservable then runs this Completable.
`<T> Observable<T>`	`startWith(Observable<T> other)` Returns an Observable which first delivers the events of the other Observable then runs this Completable.
`Disposable`	`subscribe()` Subscribes to this Completable and returns a Disposable which can be used to cancel the subscription.
`void`	`subscribe(Completable.CompletableSubscriber s)` Subscribes the given CompletableSubscriber to this Completable instance.
`Disposable`	`subscribe(Consumer<? super java.lang.Throwable> onError, java.lang.Runnable onComplete)` Subscribes to this Completable and calls back either the onError or onComplete functions.
`void`	`subscribe(NbpObservable.NbpSubscriber<?> s)` Subscribes a non-backpressure NbpSubscriberto this Completable instance which will receive only an onError or onComplete event.
`Disposable`	`subscribe(java.lang.Runnable onComplete)` Subscribes to this Completable and calls the given Runnable when this Completable completes normally.
`<T> void`	`subscribe(org.reactivestreams.Subscriber<T> s)` Subscribes a reactive-streams Subscriber to this Completable instance which will receive only an onError or onComplete event.
`Completable`	`subscribeOn(Scheduler scheduler)` Returns a Completable which subscribes the child subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the scheduler.
`Completable`	`timeout(long timeout, java.util.concurrent.TimeUnit unit)` Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
`Completable`	`timeout(long timeout, java.util.concurrent.TimeUnit unit, Completable other)` Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time.
`Completable`	`timeout(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler)` Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
`Completable`	`timeout(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Completable other)` Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time while "waiting" on the specified scheduler.
`Completable`	`timeout0(long timeout, java.util.concurrent.TimeUnit unit, Scheduler scheduler, Completable other)` Returns a Completable that runs this Completable and optionally switches to the other Completable in case this Completable doesn't complete within the given time while "waiting" on the specified scheduler.
`static Completable`	`timer(long delay, java.util.concurrent.TimeUnit unit)` Returns a Completable instance that fires its onComplete event after the given delay ellapsed.
`static Completable`	`timer(long delay, java.util.concurrent.TimeUnit unit, Scheduler scheduler)` Returns a Completable instance that fires its onComplete event after the given delay ellapsed by using the supplied scheduler.
`<U> U`	`to(Function<? super Completable,U> converter)` Allows fluent conversion to another type via a function callback.
`<T> Observable<T>`	`toFlowable()` Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
`<T> NbpObservable<T>`	`toNbpObservable()` Returns an NbpObservable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
`<T> Single<T>`	`toSingle(Supplier<? extends T> completionValueSupplier)` Convers this Completable into a Single which when this Completable completes normally, calls the given supplier and emits its returned value through onSuccess.
`<T> Single<T>`	`toSingleDefault(T completionValue)` Convers this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
`Completable`	`unsubscribeOn(Scheduler scheduler)` Returns a Completable which makes sure when a subscriber cancels the subscription, the dispose is called on the specified scheduler
`static <R> Completable`	`using(Supplier<R> resourceSupplier, Function<? super R,? extends Completable> completableFunction, Consumer<? super R> disposer)` Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active.
`static <R> Completable`	`using(Supplier<R> resourceSupplier, Function<? super R,? extends Completable> completableFunction, Consumer<? super R> disposer, boolean eager)` Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active and performs eager or lazy resource disposition.

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

- Constructor Detail
  - Completable
```
protected Completable(Completable.CompletableOnSubscribe onSubscribe)
```
    Constructs a Completable instance with the given onSubscribe callback.
    
    Parameters:
    
    onSubscribe - the callback that will receive CompletableSubscribers when they subscribe, not null (not verified)
- Method Detail
  - amb
```
@SchedulerSupport(value=NONE)
public static Completable amb(Completable... sources)
```
    Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and cancels all other Completables.
    
    Parameters:
    
    sources - the array of source Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - amb
```
@SchedulerSupport(value=NONE)
public static Completable amb(java.lang.Iterable<? extends Completable> sources)
```
    Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and cancels all other Completables.
    
    Parameters:
    
    sources - the array of source Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - complete
```
@SchedulerSupport(value=NONE)
public static Completable complete()
```
    Returns a Completable instance that completes immediately when subscribed to.
    
    Returns:
    
    a Completable instance that completes immediately
  - concat
```
@SchedulerSupport(value=NONE)
public static Completable concat(Completable... sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the Completable instance which completes only when all sources complete
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - concat
```
@SchedulerSupport(value=NONE)
public static Completable concat(java.lang.Iterable<? extends Completable> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the Completable instance which completes only when all sources complete
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - concat
```
@SchedulerSupport(value=NONE)
public static Completable concat(Observable<? extends Completable> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Parameters:
    
    sources - the sources to concatenate
    
    Returns:
    
    the Completable instance which completes only when all sources complete
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - concat
```
@SchedulerSupport(value=NONE)
public static Completable concat(Observable<? extends Completable> sources,
                                                                int prefetch)
```
    Returns a Completable which completes only when all sources complete, one after another.
    
    Parameters:
    
    sources - the sources to concatenate
    
    prefetch - the number of sources to prefetch from the sources
    
    Returns:
    
    the Completable instance which completes only when all sources complete
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - create
```
@SchedulerSupport(value=NONE)
public static Completable create(Completable.CompletableOnSubscribe onSubscribe)
```
    Constructs a Completable instance by wrapping the given onSubscribe callback.
    
    Parameters:
    
    onSubscribe - the callback which will receive the CompletableSubscriber instances when the Completable is subscribed to.
    
    Returns:
    
    the created Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onSubscribe is null
  - defer
```
@SchedulerSupport(value=NONE)
public static Completable defer(Supplier<? extends Completable> completableSupplier)
```
    Defers the subscription to a Completable instance returned by a supplier.
    
    Parameters:
    
    completableSupplier - the supplier that returns the Completable that will be subscribed to.
    
    Returns:
    
    the Completable instance
  - error
```
@SchedulerSupport(value=NONE)
public static Completable error(Supplier<? extends java.lang.Throwable> errorSupplier)
```
    Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
    If the errorSupplier returns null, the child CompletableSubscribers will receive a NullPointerException.
    
    Parameters:
    
    errorSupplier - the error supplier, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if errorSupplier is null
  - error
```
@SchedulerSupport(value=NONE)
public static Completable error(java.lang.Throwable error)
```
    Creates a Completable instance that emits the given Throwable exception to subscribers.
    
    Parameters:
    
    error - the Throwable instance to emit, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if error is null
  - fromCallable
```
@SchedulerSupport(value=NONE)
public static Completable fromCallable(java.util.concurrent.Callable<?> callable)
```
    Returns a Completable which when subscribed, executes the callable function, ignores its normal result and emits onError or onCompleted only.
    
    Parameters:
    
    callable - the callable instance to execute for each subscriber
    
    Returns:
    
    the new Completable instance
  - fromFlowable
```
@SchedulerSupport(value=NONE)
public static <T> Completable fromFlowable(Observable<T> flowable)
```
    Returns a Completable instance that subscribes to the given flowable, ignores all values and emits only the terminal event.
    
    Type Parameters:
    
    T - the type of the flowable
    
    Parameters:
    
    flowable - the Flowable instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if flowable is null
  - fromNbpObservable
```
@SchedulerSupport(value=NONE)
public static <T> Completable fromNbpObservable(NbpObservable<T> observable)
```
    Returns a Completable instance that subscribes to the given NbpObservable, ignores all values and emits only the terminal event.
    
    Type Parameters:
    
    T - the type of the NbpObservable
    
    Parameters:
    
    observable - the Observable instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if flowable is null
  - fromRunnable
```
@SchedulerSupport(value=NONE)
public static Completable fromRunnable(java.lang.Runnable run)
```
    Returns a Completable instance that runs the given Runnable for each subscriber and emits either an unchecked exception or simply completes.
    
    Parameters:
    
    run - the runnable to run for each subscriber
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if run is null
  - fromSingle
```
@SchedulerSupport(value=NONE)
public static <T> Completable fromSingle(Single<T> single)
```
    Returns a Completable instance that when subscribed to, subscribes to the Single instance and emits a completion event if the single emits onSuccess or forwards any onError events.
    
    Type Parameters:
    
    T - the value type of the Single
    
    Parameters:
    
    single - the Single instance to subscribe to, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if single is null
  - merge
```
public static Completable merge(Completable... sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
    
    Parameters:
    
    sources - the iterable sequence of sources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - merge
```
@SchedulerSupport(value=NONE)
public static Completable merge(java.lang.Iterable<? extends Completable> sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
    
    Parameters:
    
    sources - the iterable sequence of sources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - merge
```
public static Completable merge(Observable<? extends Completable> sources)
```
    Returns a Completable instance that subscribes to all sources at once and completes only when all source Completables complete or one of them emits an error.
    
    Parameters:
    
    sources - the iterable sequence of sources.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - merge
```
public static Completable merge(Observable<? extends Completable> sources,
                                int maxConcurrency)
```
    Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source Completables complete or one of them emits an error.
    
    Parameters:
    
    sources - the iterable sequence of sources.
    
    maxConcurrency - the maximum number of concurrent subscriptions
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
    
    java.lang.IllegalArgumentException - if maxConcurrency is less than 1
  - merge0
```
protected static Completable merge0(Observable<? extends Completable> sources,
                                    int maxConcurrency,
                                    boolean delayErrors)
```
    Returns a Completable instance that keeps subscriptions to a limited number of sources at once and completes only when all source Completables terminate in one way or another, combining any exceptions thrown by either the sources Observable or the inner Completable instances.
    
    Parameters:
    
    sources - the iterable sequence of sources.
    
    maxConcurrency - the maximum number of concurrent subscriptions
    
    delayErrors - delay all errors from the main source and from the inner Completables?
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
    
    java.lang.IllegalArgumentException - if maxConcurrency is less than 1
  - mergeDelayError
```
public static Completable mergeDelayError(Completable... sources)
```
    Returns a Completable that subscribes to all Completables in the source array and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
    
    Parameters:
    
    sources - the array of Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - mergeDelayError
```
public static Completable mergeDelayError(java.lang.Iterable<? extends Completable> sources)
```
    Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
    
    Parameters:
    
    sources - the sequence of Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - mergeDelayError
```
public static Completable mergeDelayError(Observable<? extends Completable> sources)
```
    Returns a Completable that subscribes to all Completables in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
    
    Parameters:
    
    sources - the sequence of Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - mergeDelayError
```
public static Completable mergeDelayError(Observable<? extends Completable> sources,
                                          int maxConcurrency)
```
    Returns a Completable that subscribes to a limited number of inner Completables at once in the source sequence and delays any error emitted by either the sources observable or any of the inner Completables until all of them terminate in a way or another.
    
    Parameters:
    
    sources - the sequence of Completables
    
    maxConcurrency - the maximum number of concurrent subscriptions to Completables
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if sources is null
  - never
```
public static Completable never()
```
    Returns a Completable that never calls onError or onComplete.
    
    Returns:
    
    the singleton instance that never calls onError or onComplete
  - timer
```
@SchedulerSupport(value=COMPUTATION)
public static Completable timer(long delay,
                                                                      java.util.concurrent.TimeUnit unit)
```
    Returns a Completable instance that fires its onComplete event after the given delay ellapsed.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    Returns:
    
    the new Completable instance
  - timer
```
@SchedulerSupport(value=CUSTOM)
public static Completable timer(long delay,
                                                                 java.util.concurrent.TimeUnit unit,
                                                                 Scheduler scheduler)
```
    Returns a Completable instance that fires its onComplete event after the given delay ellapsed by using the supplied scheduler.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    scheduler - the scheduler where to emit the complete event
    
    Returns:
    
    the new Completable instance
  - using
```
public static <R> Completable using(Supplier<R> resourceSupplier,
                                    Function<? super R,? extends Completable> completableFunction,
                                    Consumer<? super R> disposer)
```
    Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active.
    This overload performs an eager unsubscription before the terminal event is emitted.
    
    Type Parameters:
    
    R - the resource type
    
    Parameters:
    
    resourceSupplier - the supplier that returns a resource to be managed.
    
    completableFunction - the function that given a resource returns a Completable instance that will be subscribed to
    
    disposer - the consumer that disposes the resource created by the resource supplier
    
    Returns:
    
    the new Completable instance
  - using
```
public static <R> Completable using(Supplier<R> resourceSupplier,
                                    Function<? super R,? extends Completable> completableFunction,
                                    Consumer<? super R> disposer,
                                    boolean eager)
```
    Returns a Completable instance which manages a resource along with a custom Completable instance while the subscription is active and performs eager or lazy resource disposition.
    If this overload performs a lazy unsubscription after the terminal event is emitted. Exceptions thrown at this time will be delivered to RxJavaPlugins only.
    
    Type Parameters:
    
    R - the resource type
    
    Parameters:
    
    resourceSupplier - the supplier that returns a resource to be managed
    
    completableFunction - the function that given a resource returns a non-null Completable instance that will be subscribed to
    
    disposer - the consumer that disposes the resource created by the resource supplier
    
    eager - if true, the resource is disposed before the terminal event is emitted, if false, the resource is disposed after the terminal event has been emitted
    
    Returns:
    
    the new Completable instance
  - ambWith
```
@SchedulerSupport(value=NONE)
public final Completable ambWith(Completable other)
```
    Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
    
    Parameters:
    
    other - the other Completable, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - await
```
@SchedulerSupport(value=NONE)
public final void await()
```
    Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.
    
    Throws:
    
    java.lang.RuntimeException - wrapping an InterruptedException if the current thread is interrupted
  - await
```
@SchedulerSupport(value=NONE)
public final boolean await(long timeout,
                                                          java.util.concurrent.TimeUnit unit)
```
    Subscribes to and awaits the termination of this Completable instance in a blocking manner with a specific timeout and rethrows any exception emitted within the timeout window.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    Returns:
    
    true if the this Completable instance completed normally within the time limit, false if the timeout ellapsed before this Completable terminated.
    
    Throws:
    
    java.lang.RuntimeException - wrapping an InterruptedException if the current thread is interrupted
  - compose
```
@SchedulerSupport(value=NONE)
public final Completable compose(Completable.CompletableTransformer transformer)
```
    Calls the given transformer function with this instance and returns the function's resulting Completable.
    
    Parameters:
    
    transformer - the transformer function, not null
    
    Returns:
    
    the Completable returned by the function
    
    Throws:
    
    java.lang.NullPointerException - if transformer is null
  - concatWith
```
@SchedulerSupport(value=NONE)
public final Completable concatWith(Completable other)
```
    Concatenates this Completable with another Completable.
    
    Parameters:
    
    other - the other Completable, not null
    
    Returns:
    
    the new Completable which subscribes to this and then the other Completable
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - delay
```
@SchedulerSupport(value=COMPUTATION)
public final Completable delay(long delay,
                                                                     java.util.concurrent.TimeUnit unit)
```
    Returns a Completable which delays the emission of the completion event by the given time.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit is null
  - delay
```
@SchedulerSupport(value=CUSTOM)
public final Completable delay(long delay,
                                                                java.util.concurrent.TimeUnit unit,
                                                                Scheduler scheduler)
```
    Returns a Completable which delays the emission of the completion event by the given time while running on the specified scheduler.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    scheduler - the scheduler to run the delayed completion on
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit or scheduler is null
  - delay
```
@SchedulerSupport(value=CUSTOM)
public final Completable delay(long delay,
                                                                java.util.concurrent.TimeUnit unit,
                                                                Scheduler scheduler,
                                                                boolean delayError)
```
    Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified scheduler.
    
    Parameters:
    
    delay - the delay time
    
    unit - the delay unit
    
    scheduler - the scheduler to run the delayed completion on
    
    delayError - delay the error emission as well?
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit or scheduler is null
  - doOnComplete
```
@SchedulerSupport(value=NONE)
public final Completable doOnComplete(java.lang.Runnable onComplete)
```
    Returns a Completable which calls the given onComplete callback if this Completable completes.
    
    Parameters:
    
    onComplete - the callback to call when this emits an onComplete event
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onComplete is null
  - doOnDispose
```
@SchedulerSupport(value=NONE)
public final Completable doOnDispose(java.lang.Runnable onDispose)
```
    Returns a Completable which calls the giveon onDispose callback if the child subscriber cancels the subscription.
    
    Parameters:
    
    onDispose - the callback to call when the child subscriber cancels the subscription
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onDispose is null
  - doOnError
```
@SchedulerSupport(value=NONE)
public final Completable doOnError(Consumer<? super java.lang.Throwable> onError)
```
    Returns a Completable which calls the given onError callback if this Completable emits an error.
    
    Parameters:
    
    onError - the error callback
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onError is null
  - doOnLifecycle
```
@SchedulerSupport(value=NONE)
protected final Completable doOnLifecycle(Consumer<? super Disposable> onSubscribe,
                                                                         Consumer<? super java.lang.Throwable> onError,
                                                                         java.lang.Runnable onComplete,
                                                                         java.lang.Runnable onAfterComplete,
                                                                         java.lang.Runnable onDisposed)
```
    Returns a Completable instance that calls the various callbacks on the specific lifecycle events.
    
    Parameters:
    
    onSubscribe - the consumer called when a CompletableSubscriber subscribes.
    
    onError - the consumer called when this emits an onError event
    
    onComplete - the runnable called just before when this Completable completes normally
    
    onAfterComplete - the runnable called after this Completable completes normally
    
    onDisposed - the runnable called when the child cancels the subscription
    
    Returns:
    
    the new Completable instance
  - doOnSubscribe
```
@SchedulerSupport(value=NONE)
public final Completable doOnSubscribe(Consumer<? super Disposable> onSubscribe)
```
    Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
    
    Parameters:
    
    onSubscribe - the callback called when a child subscriber subscribes
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onSubscribe is null
  - doOnTerminate
```
@SchedulerSupport(value=NONE)
public final Completable doOnTerminate(java.lang.Runnable onTerminate)
```
    Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception
    
    Parameters:
    
    onTerminate - the callback to call just before this Completable terminates
    
    Returns:
    
    the new Completable instance
  - endWith
```
@SchedulerSupport(value=NONE)
public final Completable endWith(Completable other)
```
    Returns a completable that first runs this Completable and then the other completable.
    This is an alias for concatWith(Completable).
    
    Parameters:
    
    other - the other Completable, not null
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - endWith
```
@SchedulerSupport(value=CUSTOM)
public final <T> NbpObservable<T> endWith(NbpObservable<T> next)
```
    Returns an NbpObservable that first runs this Completable instance and resumes with the given next Observable.
    
    Type Parameters:
    
    T - the type of the NbpObservable
    
    Parameters:
    
    next - the next Observable to continue
    
    Returns:
    
    the new Observable instance
    
    Throws:
    
    java.lang.NullPointerException - if next is null
  - endWith
```
@SchedulerSupport(value=CUSTOM)
public final <T> Observable<T> endWith(Observable<T> next)
```
    Returns an Observable that first runs this Completable instance and resumes with the given next Observable.
    
    Type Parameters:
    
    T - the value type of the observable
    
    Parameters:
    
    next - the next Observable to continue
    
    Returns:
    
    the new Observable instance
    
    Throws:
    
    java.lang.NullPointerException - if next is null
  - finallyDo
```
@SchedulerSupport(value=NONE)
public final Completable finallyDo(java.lang.Runnable onAfterComplete)
```
    Returns a Completable instace that calls the given onAfterComplete callback after this Completable completes normally.
    
    Parameters:
    
    onAfterComplete - the callback to call after this Completable emits an onComplete event.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onAfterComplete is null
  - get
```
@SchedulerSupport(value=NONE)
public final java.lang.Throwable get()
```
    Subscribes to this Completable instance and blocks until it terminates, then returns null or the emitted exception if any.
    
    Returns:
    
    the throwable if this terminated with an error, null otherwise
    
    Throws:
    
    java.lang.RuntimeException - that wraps an InterruptedException if the wait is interrupted
  - get
```
@SchedulerSupport(value=NONE)
public final java.lang.Throwable get(long timeout,
                                                                    java.util.concurrent.TimeUnit unit)
```
    Subscribes to this Completable instance and blocks until it terminates or the specified timeout ellapses, then returns null for normal termination or the emitted exception if any.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the time unit
    
    Returns:
    
    the throwable if this terminated with an error, null otherwise
    
    Throws:
    
    java.lang.RuntimeException - that wraps an InterruptedException if the wait is interrupted or TimeoutException if the specified timeout ellapsed before it
  - lift
```
@SchedulerSupport(value=NONE)
public final Completable lift(Completable.CompletableOperator onLift)
```
    Lifts a CompletableSubscriber transformation into the chain of Completables.
    
    Parameters:
    
    onLift - the lifting function that transforms the child subscriber with a parent subscriber.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if onLift is null
  - mergeWith
```
@SchedulerSupport(value=NONE)
public final Completable mergeWith(Completable other)
```
    Returns a Completable which subscribes to this and the other Completable and completes when both of them complete or one emits an error.
    
    Parameters:
    
    other - the other Completable instance
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - observeOn
```
@SchedulerSupport(value=CUSTOM)
public final Completable observeOn(Scheduler scheduler)
```
    Returns a Completable which emits the terminal events from the thread of the specified scheduler.
    
    Parameters:
    
    scheduler - the scheduler to emit terminal events on
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if scheduler is null
  - onErrorComplete
```
@SchedulerSupport(value=NONE)
public final Completable onErrorComplete()
```
    Returns a Completable instance that if this Completable emits an error, it will emit an onComplete and swallow the throwable.
    
    Returns:
    
    the new Completable instance
  - onErrorComplete
```
@SchedulerSupport(value=NONE)
public final Completable onErrorComplete(Predicate<? super java.lang.Throwable> predicate)
```
    Returns a Completable instance that if this Completable emits an error and the predicate returns true, it will emit an onComplete and swallow the throwable.
    
    Parameters:
    
    predicate - the predicate to call when an Throwable is emitted which should return true if the Throwable should be swallowed and replaced with an onComplete.
    
    Returns:
    
    the new Completable instance
  - onErrorResumeNext
```
@SchedulerSupport(value=NONE)
public final Completable onErrorResumeNext(Function<? super java.lang.Throwable,? extends Completable> errorMapper)
```
    Returns a Completable instance that when encounters an error from this Completable, calls the specified mapper function that returns another Completable instance for it and resumes the execution with it.
    
    Parameters:
    
    errorMapper - the mapper function that takes the error and should return a Completable as continuation.
    
    Returns:
    
    the new Completable instance
  - repeat
```
@SchedulerSupport(value=NONE)
public final Completable repeat()
```
    Returns a Completable that repeatedly subscribes to this Completable until cancelled.
    
    Returns:
    
    the new Completable instance
  - repeat
```
@SchedulerSupport(value=NONE)
public final Completable repeat(long times)
```
    Returns a Completable that subscribes repeatedly at most the given times to this Completable.
    
    Parameters:
    
    times - the number of times the resubscription should happen
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.IllegalArgumentException - if times is less than zero
  - repeatUntil
```
@SchedulerSupport(value=NONE)
public final Completable repeatUntil(BooleanSupplier stop)
```
    Returns a Completable that repeatedly subscribes to this Completable so long as the given stop supplier returns false.
    
    Parameters:
    
    stop - the supplier that should return true to stop resubscribing.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if stop is null
  - repeatWhen
```
@SchedulerSupport(value=NONE)
public final Completable repeatWhen(Function<? super Observable<java.lang.Object>,? extends org.reactivestreams.Publisher<java.lang.Object>> handler)
```
    Returns a Completable instance that repeats when the Publisher returned by the handler emits an item or completes when this Publisher emits a completed event.
    
    Parameters:
    
    handler - the function that transforms the stream of values indicating the completion of this Completable and returns a Publisher that emits items for repeating or completes to indicate the repetition should stop
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if stop is null
  - retry
```
@SchedulerSupport(value=NONE)
public final Completable retry()
```
    Returns a Completable that retries this Completable as long as it emits an onError event.
    
    Returns:
    
    the new Completable instance
  - retry
```
@SchedulerSupport(value=NONE)
public final Completable retry(BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)
```
    Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.
    
    Parameters:
    
    predicate - the predicate called when this emits an error with the repeat count and the latest exception and should return true to retry.
    
    Returns:
    
    the new Completable instance
  - retry
```
@SchedulerSupport(value=NONE)
public final Completable retry(long times)
```
    Returns a Completable that when this Completable emits an error, retries at most the given number of times before giving up and emitting the last error.
    
    Parameters:
    
    times - the number of times the returned Completable should retry this Completable
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.IllegalArgumentException - if times is negative
  - retry
```
@SchedulerSupport(value=NONE)
public final Completable retry(Predicate<? super java.lang.Throwable> predicate)
```
    Returns a Completable that when this Completable emits an error, calls the given predicate with the latest exception to decide whether to resubscribe to this or not.
    
    Parameters:
    
    predicate - the predicate that is called with the latest throwable and should return true to indicate the returned Completable should resubscribe to this Completable.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if predicate is null
  - retryWhen
```
@SchedulerSupport(value=NONE)
public final Completable retryWhen(Function<? super Observable<? extends java.lang.Throwable>,? extends org.reactivestreams.Publisher<java.lang.Object>> handler)
```
    Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through an Observable and the Publisher should return a value indicating a retry in response or a terminal event indicating a termination.
    
    Parameters:
    
    handler - the handler that receives an Observable delivering Throwables and should return a Publisher that emits items to indicate retries or emits terminal events to indicate termination.
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if handler is null
  - startWith
```
@SchedulerSupport(value=NONE)
public final Completable startWith(Completable other)
```
    Returns a Completable which first runs the other Completable then this completable if the other completed normally.
    
    Parameters:
    
    other - the other completable to run first
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - startWith
```
@SchedulerSupport(value=NONE)
public final <T> NbpObservable<T> startWith(NbpObservable<T> other)
```
    Returns an NbpObservable which first delivers the events of the other NbpObservable then runs this Completable.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    other - the other NbpObservable to run first
    
    Returns:
    
    the new NbpObservable instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - startWith
```
@SchedulerSupport(value=NONE)
public final <T> Observable<T> startWith(Observable<T> other)
```
    Returns an Observable which first delivers the events of the other Observable then runs this Completable.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    other - the other Observable to run first
    
    Returns:
    
    the new Observable instance
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - subscribe
```
@SchedulerSupport(value=NONE)
public final Disposable subscribe()
```
    Subscribes to this Completable and returns a Disposable which can be used to cancel the subscription.
    
    Returns:
    
    the Disposable that allows cancelling the subscription
  - subscribe
```
@SchedulerSupport(value=NONE)
public final void subscribe(Completable.CompletableSubscriber s)
```
    Subscribes the given CompletableSubscriber to this Completable instance.
    
    Parameters:
    
    s - the CompletableSubscriber, not null
    
    Throws:
    
    java.lang.NullPointerException - if s is null
  - subscribe
```
@SchedulerSupport(value=NONE)
public final Disposable subscribe(Consumer<? super java.lang.Throwable> onError,
                                                                 java.lang.Runnable onComplete)
```
    Subscribes to this Completable and calls back either the onError or onComplete functions.
    
    Parameters:
    
    onError - the consumer that is called if this Completable emits an error
    
    onComplete - the runnable that is called if the Completable completes normally
    
    Returns:
    
    the Disposable that can be used for cancelling the subscription asynchronously
    
    Throws:
    
    java.lang.NullPointerException - if either callback is null
  - subscribe
```
@SchedulerSupport(value=NONE)
public final void subscribe(NbpObservable.NbpSubscriber<?> s)
```
    Subscribes a non-backpressure NbpSubscriberto this Completable instance which will receive only an onError or onComplete event.
    
    Parameters:
    
    s - the NbpSubscriber instance, not null
    
    Throws:
    
    java.lang.NullPointerException - if s is null
  - subscribe
```
@SchedulerSupport(value=NONE)
public final Disposable subscribe(java.lang.Runnable onComplete)
```
    Subscribes to this Completable and calls the given Runnable when this Completable completes normally.
    If this Completable emits an error, it is sent to RxJavaPlugins.onError and gets swallowed.
    
    Parameters:
    
    onComplete - the runnable called when this Completable completes normally
    
    Returns:
    
    the Disposable that allows cancelling the subscription
  - subscribe
```
@SchedulerSupport(value=NONE)
public final <T> void subscribe(org.reactivestreams.Subscriber<T> s)
```
    Subscribes a reactive-streams Subscriber to this Completable instance which will receive only an onError or onComplete event.
    
    Type Parameters:
    
    T - the value type of the subscriber
    
    Parameters:
    
    s - the reactive-streams Subscriber, not null
    
    Throws:
    
    java.lang.NullPointerException - if s is null
  - subscribeOn
```
@SchedulerSupport(value=CUSTOM)
public final Completable subscribeOn(Scheduler scheduler)
```
    Returns a Completable which subscribes the child subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the scheduler.
    
    Parameters:
    
    scheduler - the Scheduler to subscribe on
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if scheduler is null
  - timeout
```
@SchedulerSupport(value=COMPUTATION)
public final Completable timeout(long timeout,
                                                                       java.util.concurrent.TimeUnit unit)
```
    Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit is null
  - timeout
```
@SchedulerSupport(value=COMPUTATION)
public final Completable timeout(long timeout,
                                                                       java.util.concurrent.TimeUnit unit,
                                                                       Completable other)
```
    Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    other - the other Completable instance to switch to in case of a timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit or other is null
  - timeout
```
@SchedulerSupport(value=CUSTOM)
public final Completable timeout(long timeout,
                                                                  java.util.concurrent.TimeUnit unit,
                                                                  Scheduler scheduler)
```
    Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    scheduler - the scheduler to use to wait for completion
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit or scheduler is null
  - timeout
```
@SchedulerSupport(value=CUSTOM)
public final Completable timeout(long timeout,
                                                                  java.util.concurrent.TimeUnit unit,
                                                                  Scheduler scheduler,
                                                                  Completable other)
```
    Returns a Completable that runs this Completable and switches to the other Completable in case this Completable doesn't complete within the given time while "waiting" on the specified scheduler.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    scheduler - the scheduler to use to wait for completion
    
    other - the other Completable instance to switch to in case of a timeout
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit, scheduler or other is null
  - timeout0
```
@SchedulerSupport(value=CUSTOM)
public final Completable timeout0(long timeout,
                                                                   java.util.concurrent.TimeUnit unit,
                                                                   Scheduler scheduler,
                                                                   Completable other)
```
    Returns a Completable that runs this Completable and optionally switches to the other Completable in case this Completable doesn't complete within the given time while "waiting" on the specified scheduler.
    
    Parameters:
    
    timeout - the timeout value
    
    unit - the timeout unit
    
    scheduler - the scheduler to use to wait for completion
    
    other - the other Completable instance to switch to in case of a timeout, if null a TimeoutException is emitted instead
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if unit or scheduler
  - to
```
@SchedulerSupport(value=NONE)
public final <U> U to(Function<? super Completable,U> converter)
```
    Allows fluent conversion to another type via a function callback.
    
    Type Parameters:
    
    U - the output type
    
    Parameters:
    
    converter - the function called with this which should return some other value.
    
    Returns:
    
    the converted value
    
    Throws:
    
    java.lang.NullPointerException - if converter is null
  - toFlowable
```
@SchedulerSupport(value=NONE)
public final <T> Observable<T> toFlowable()
```
    Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    the new Observable created
  - toNbpObservable
```
@SchedulerSupport(value=NONE)
public final <T> NbpObservable<T> toNbpObservable()
```
    Returns an NbpObservable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
    
    Type Parameters:
    
    T - the value type
    
    Returns:
    
    the new NbpObservable created
  - toSingle
```
@SchedulerSupport(value=NONE)
public final <T> Single<T> toSingle(Supplier<? extends T> completionValueSupplier)
```
    Convers this Completable into a Single which when this Completable completes normally, calls the given supplier and emits its returned value through onSuccess.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    completionValueSupplier - the value supplier called when this Completable completes normally
    
    Returns:
    
    the new Single instance
    
    Throws:
    
    java.lang.NullPointerException - if completionValueSupplier is null
  - toSingleDefault
```
@SchedulerSupport(value=NONE)
public final <T> Single<T> toSingleDefault(T completionValue)
```
    Convers this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    completionValue - the value to emit when this Completable completes normally
    
    Returns:
    
    the new Single instance
    
    Throws:
    
    java.lang.NullPointerException - if completionValue is null
  - unsubscribeOn
```
@SchedulerSupport(value=CUSTOM)
public final Completable unsubscribeOn(Scheduler scheduler)
```
    Returns a Completable which makes sure when a subscriber cancels the subscription, the dispose is called on the specified scheduler
    
    Parameters:
    
    scheduler - the target scheduler where to execute the cancellation
    
    Returns:
    
    the new Completable instance
    
    Throws:
    
    java.lang.NullPointerException - if scheduler is null

Class Completable

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Completable

Method Detail

amb

amb

complete

concat

concat

concat

concat

create

defer

error

error

fromCallable

fromFlowable

fromNbpObservable

fromRunnable

fromSingle

merge

merge

merge

merge

merge0

mergeDelayError

mergeDelayError

mergeDelayError

mergeDelayError

never

timer

timer

using

using

ambWith

await

await

compose

concatWith

delay

delay

delay

doOnComplete

doOnDispose

doOnError

doOnLifecycle

doOnSubscribe

doOnTerminate

endWith

endWith

endWith

finallyDo

get

get

lift

mergeWith

observeOn

onErrorComplete

onErrorComplete

onErrorResumeNext

repeat

repeat

repeatUntil

repeatWhen

retry

retry

retry

retry

retryWhen

startWith

startWith

startWith

subscribe

subscribe

subscribe

subscribe