Movatterモバイル変換

java.lang.Object
- io.reactivex.Completable

All Implemented Interfaces:
CompletableSource
Direct Known Subclasses:
CompletableSubject
```
public abstract classCompletableextendsObjectimplementsCompletableSource
```
TheCompletable class represents a deferred computation without any value but only indication for completion or exception.
Completable behaves similarly toObservable except that it can only emit either a completion or error signal (there is noonNext oronSuccess as with the other reactive types).
TheCompletable class implements theCompletableSource base interface and the default consumer type it interacts with is theCompletableObserver via thesubscribe(CompletableObserver) method. TheCompletable operates with the following sequential protocol:
```
     onSubscribe (onError | onComplete)?
```
Note that as with theObservable protocol,onError andonComplete are mutually exclusive events.
LikeObservable, a runningCompletable can be stopped through theDisposable instance provided to consumers throughSingleObserver.onSubscribe(io.reactivex.disposables.Disposable).
Like anObservable, aCompletable is lazy, can be either "hot" or "cold", synchronous or asynchronous.Completable instances returned by the methods of this class arecold and there is a standardhot implementation in the form of a subject:CompletableSubject.
The documentation for this class makes use of marble diagrams. The following legend explains these diagrams:
SeeFlowable orObservable for the implementation of the Reactive Pattern for a stream or vector of values.
Example:
```
 Disposable d = Completable.complete()    .delay(10, TimeUnit.SECONDS, Schedulers.io())    .subscribeWith(new DisposableCompletableObserver() {        @Override        public void onStart() {            System.out.println("Started");        }        @Override        public void onError(Throwable error) {            error.printStackTrace();        }        @Override        public void onComplete() {            System.out.println("Done!");        }    });  Thread.sleep(5000);  d.dispose();
```
Note that by design, subscriptions viasubscribe(CompletableObserver) can't be disposed from the outside (hence thevoid return of thesubscribe(CompletableObserver) method) and it is the responsibility of the implementor of theCompletableObserver to allow this to happen. RxJava supports such usage with the standardDisposableCompletableObserver instance. For convenience, thesubscribeWith(CompletableObserver) method is provided as well to allow working with aCompletableObserver (or subclass) instance to be applied with in a fluent manner (such as in the example above).
See Also:
DisposableCompletableObserver

Constructor Summary
Constructors
Constructor and Description
Completable()

Constructors
Constructor and Description
`Completable()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`staticCompletable`	`amb(Iterable<? extendsCompletableSource> sources)` Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.
`staticCompletable`	`ambArray(CompletableSource... sources)` Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.
`Completable`	`ambWith(CompletableSource other)` Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
`Completable`	`andThen(CompletableSource next)` Returns a Completable that first runs this Completable and then the other completable.
`<T> Maybe<T>`	`andThen(MaybeSource<T> next)` Returns a`Maybe` which will subscribe to this Completable and once that is completed then will subscribe to the`next` MaybeSource.
`<T> Observable<T>`	`andThen(ObservableSource<T> next)` Returns an Observable which will subscribe to this Completable and once that is completed then will subscribe to the`next` ObservableSource.
`<T> Flowable<T>`	`andThen(Publisher<T> next)` Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to the`next` Flowable.
`<T> Single<T>`	`andThen(SingleSource<T> next)` Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to the`next` SingleSource.
`<R> R`	`as(CompletableConverter<? extends R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`void`	`blockingAwait()` Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.
`boolean`	`blockingAwait(long timeout,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.
`Throwable`	`blockingGet()` Subscribes to this Completable instance and blocks until it terminates, then returns null or the emitted exception if any.
`Throwable`	`blockingGet(long timeout,TimeUnit unit)` Subscribes to this Completable instance and blocks until it terminates or the specified timeout elapses, then returns null for normal termination or the emitted exception if any.
`Completable`	`cache()` Subscribes to this Completable only once, when the first CompletableObserver subscribes to the result Completable, caches its terminal event and relays/replays it to observers.
`staticCompletable`	`complete()` Returns a Completable instance that completes immediately when subscribed to.
`Completable`	`compose(CompletableTransformer transformer)` Calls the given transformer function with this instance and returns the function's resulting Completable.
`staticCompletable`	`concat(Iterable<? extendsCompletableSource> sources)` Returns a Completable which completes only when all sources complete, one after another.
`staticCompletable`	`concat(Publisher<? extendsCompletableSource> sources)` Returns a Completable which completes only when all sources complete, one after another.
`staticCompletable`	`concat(Publisher<? extendsCompletableSource> sources, int prefetch)` Returns a Completable which completes only when all sources complete, one after another.
`staticCompletable`	`concatArray(CompletableSource... sources)` Returns a Completable which completes only when all sources complete, one after another.
`Completable`	`concatWith(CompletableSource other)` Concatenates this Completable with another Completable.
`staticCompletable`	`create(CompletableOnSubscribe source)` Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
`staticCompletable`	`defer(Callable<? extendsCompletableSource> completableSupplier)` Defers the subscription to a Completable instance returned by a supplier.
`Completable`	`delay(long delay,TimeUnit unit)` Returns a Completable which delays the emission of the completion event by the given time.
`Completable`	`delay(long delay,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,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`	`delaySubscription(long delay,TimeUnit unit)` Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time.
`Completable`	`delaySubscription(long delay,TimeUnit unit,Scheduler scheduler)` Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time, both waiting and subscribing on a given Scheduler.
`Completable`	`doAfterTerminate(Action onAfterTerminate)` Returns a Completable instance that calls the given onTerminate callback after this Completable completes normally or with an exception.
`Completable`	`doFinally(Action onFinally)` Calls the specified action after this Completable signals onError or onComplete or gets disposed by the downstream.
`Completable`	`doOnComplete(Action onComplete)` Returns a Completable which calls the given onComplete callback if this Completable completes.
`Completable`	`doOnDispose(Action onDispose)` Calls the shared`Action` if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.
`Completable`	`doOnError(Consumer<? superThrowable> onError)` Returns a Completable which calls the given onError callback if this Completable emits an error.
`Completable`	`doOnEvent(Consumer<? superThrowable> onEvent)` Returns a Completable which calls the given onEvent callback with the (throwable) for an onError or (null) for an onComplete signal from this Completable before delivering said signal to the downstream.
`Completable`	`doOnSubscribe(Consumer<? superDisposable> onSubscribe)` Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
`Completable`	`doOnTerminate(Action onTerminate)` Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception.
`staticCompletable`	`error(Callable<? extendsThrowable> errorSupplier)` Creates a Completable which calls the given error supplier for each subscriber and emits its returned Throwable.
`staticCompletable`	`error(Throwable error)` Creates a Completable instance that emits the given Throwable exception to subscribers.
`staticCompletable`	`fromAction(Action run)` Returns a Completable instance that runs the given Action for each subscriber and emits either an unchecked exception or simply completes.
`staticCompletable`	`fromCallable(Callable<?> callable)` Returns a Completable which when subscribed, executes the callable function, ignores its normal result and emits onError or onComplete only.
`staticCompletable`	`fromFuture(Future<?> future)` Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
`static <T> Completable`	`fromMaybe(MaybeSource<T> maybe)` Returns a Completable instance that when subscribed to, subscribes to the`Maybe` instance and emits a completion event if the maybe emits`onSuccess`/`onComplete` or forwards any`onError` events.
`static <T> Completable`	`fromObservable(ObservableSource<T> observable)` Returns a Completable instance that subscribes to the given Observable, ignores all values and emits only the terminal event.
`static <T> Completable`	`fromPublisher(Publisher<T> publisher)` Returns a Completable instance that subscribes to the given publisher, ignores all values and emits only the terminal event.
`staticCompletable`	`fromRunnable(Runnable run)` Returns a Completable instance that runs the given Runnable for each subscriber and emits either its exception or simply completes.
`static <T> Completable`	`fromSingle(SingleSource<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.
`Completable`	`hide()` Hides the identity of this Completable and its Disposable.
`Completable`	`lift(CompletableOperator onLift)` This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns a`Completable` which, when subscribed to, invokes the`apply(CompletableObserver)` method of the provided`CompletableOperator` for each individual downstream`Completable` and allows the insertion of a custom operator by accessing the downstream's`CompletableObserver` during this subscription phase and providing a new`CompletableObserver`, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
`<T> Single<Notification<T>>`	`materialize()` Maps the signal types of this Completable into a`Notification` of the same kind and emits it as a single success value to downstream.
`staticCompletable`	`merge(Iterable<? extendsCompletableSource> 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.
`staticCompletable`	`merge(Publisher<? extendsCompletableSource> 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.
`staticCompletable`	`merge(Publisher<? extendsCompletableSource> 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.
`staticCompletable`	`mergeArray(CompletableSource... 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.
`staticCompletable`	`mergeArrayDelayError(CompletableSource... sources)` Returns a CompletableConsumable 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.
`staticCompletable`	`mergeDelayError(Iterable<? extendsCompletableSource> 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.
`staticCompletable`	`mergeDelayError(Publisher<? extendsCompletableSource> 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.
`staticCompletable`	`mergeDelayError(Publisher<? extendsCompletableSource> 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(CompletableSource other)` Returns a Completable which subscribes to this and the other Completable and completes when both of them complete or one emits an error.
`staticCompletable`	`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<? superThrowable> 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<? superThrowable,? extendsCompletableSource> 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`	`onTerminateDetach()` Nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose().
`Completable`	`repeat()` Returns a Completable that repeatedly subscribes to this Completable until disposed.
`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<? superFlowable<Object>,? extendsPublisher<?>> 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<? superInteger,? superThrowable> 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(long times,Predicate<? superThrowable> predicate)` Returns a Completable that when this Completable emits an error, retries at most times or until the predicate returns false, whichever happens first and emitting the last error.
`Completable`	`retry(Predicate<? superThrowable> 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<? superFlowable<Throwable>,? extendsPublisher<?>> handler)` Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.
`Completable`	`startWith(CompletableSource other)` Returns a Completable which first runs the other Completable then this completable if the other completed normally.
`<T> Observable<T>`	`startWith(Observable<T> other)` Returns an Observable which first delivers the events of the other Observable then runs this CompletableConsumable.
`<T> Flowable<T>`	`startWith(Publisher<T> other)` Returns a Flowable which first delivers the events of the other Publisher then runs this Completable.
`Disposable`	`subscribe()` Subscribes to this CompletableConsumable and returns a Disposable which can be used to dispose the subscription.
`Disposable`	`subscribe(Action onComplete)` Subscribes to this Completable and calls the given Action when this Completable completes normally.
`Disposable`	`subscribe(Action onComplete,Consumer<? superThrowable> onError)` Subscribes to this Completable and calls back either the onError or onComplete functions.
`void`	`subscribe(CompletableObserver observer)` Subscribes the given CompletableObserver to this CompletableSource instance.
`protected abstract void`	`subscribeActual(CompletableObserver observer)` Implement this method to handle the incoming`CompletableObserver`s and perform the business logic in your operator.
`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.
`<E extendsCompletableObserver> E`	`subscribeWith(E observer)` Subscribes a given CompletableObserver (subclass) to this Completable and returns the given CompletableObserver as is.
`Completable`	`takeUntil(CompletableSource other)` Terminates the downstream if this or the other`Completable` terminates (wins the termination race) while disposing the connection to the losing source.
`TestObserver<Void>`	`test()` Creates a TestObserver and subscribes it to this Completable.
`TestObserver<Void>`	`test(boolean cancelled)` Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
`Completable`	`timeout(long timeout,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,TimeUnit unit,CompletableSource 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,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,TimeUnit unit,Scheduler scheduler,CompletableSource 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.
`staticCompletable`	`timer(long delay,TimeUnit unit)` Returns a Completable instance that fires its onComplete event after the given delay elapsed.
`staticCompletable`	`timer(long delay,TimeUnit unit,Scheduler scheduler)` Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied scheduler.
`<U> U`	`to(Function<? superCompletable,U> converter)` Allows fluent conversion to another type via a function callback.
`<T> Flowable<T>`	`toFlowable()` Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
`<T> Maybe<T>`	`toMaybe()` Converts this Completable into a`Maybe`.
`<T> Observable<T>`	`toObservable()` Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
`<T> Single<T>`	`toSingle(Callable<? extends T> completionValueSupplier)` Converts 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)` Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
`staticCompletable`	`unsafeCreate(CompletableSource source)` Constructs a Completable instance by wrapping the given source callbackwithout any safeguards; you should manage the lifecycle and response to downstream disposal.
`Completable`	`unsubscribeOn(Scheduler scheduler)` Returns a Completable which makes sure when a subscriber disposes the subscription, the dispose is called on the specified scheduler.
`static <R> Completable`	`using(Callable<R> resourceSupplier,Function<? super R,? extendsCompletableSource> 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(Callable<R> resourceSupplier,Function<? super R,? extendsCompletableSource> 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.
`staticCompletable`	`wrap(CompletableSource source)` Wraps the given CompletableSource into a Completable if not already Completable.

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

- Constructor Detail
  - Completable
```
public Completable()
```
- Method Detail
  - ambArray
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable ambArray(CompletableSource... sources)
```
    Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.
    Scheduler:
    ambArray does not operate by default on a particularScheduler.
    Parameters:
    sources - the array of source Completables. A subscription to each source will occur in the same order as in this array.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
  - amb
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable amb(Iterable<? extendsCompletableSource> sources)
```
    Returns a Completable which terminates as soon as one of the source Completables terminates (normally or with an error) and disposes all other Completables.
    Scheduler:
    amb does not operate by default on a particularScheduler.
    Parameters:
    sources - the array of source Completables. A subscription to each source will occur in the same order as in this Iterable.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
  - complete
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable complete()
```
    Returns a Completable instance that completes immediately when subscribed to.
    Scheduler:
    complete does not operate by default on a particularScheduler.
    Returns:
    a Completable instance that completes immediately
  - concatArray
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable concatArray(CompletableSource... sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    Scheduler:
    concatArray does not operate by default on a particularScheduler.
    Parameters:
    sources - the sources to concatenate
    Returns:
    the Completable instance which completes only when all sources complete
    Throws:
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable concat(Iterable<? extendsCompletableSource> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    Scheduler:
    concat does not operate by default on a particularScheduler.
    Parameters:
    sources - the sources to concatenate
    Returns:
    the Completable instance which completes only when all sources complete
    Throws:
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public static Completable concat(Publisher<? extendsCompletableSource> sources)
```
    Returns a Completable which completes only when all sources complete, one after another.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    concat does not operate by default on a particularScheduler.
    Parameters:
    sources - the sources to concatenate
    Returns:
    the Completable instance which completes only when all sources complete
    Throws:
    NullPointerException - if sources is null
  - concat
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public static Completable concat(Publisher<? extendsCompletableSource> sources,        int prefetch)
```
    Returns a Completable which completes only when all sources complete, one after another.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    concat does not operate by default on a particularScheduler.
    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:
    NullPointerException - if sources is null
  - create
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable create(CompletableOnSubscribe source)
```
    Provides an API (via a cold Completable) that bridges the reactive world with the callback-style world.
    Example:
```
 Completable.create(emitter -> {     Callback listener = new Callback() {         @Override         public void onEvent(Event e) {             emitter.onComplete();         }         @Override         public void onFailure(Exception e) {             emitter.onError(e);         }     };     AutoCloseable c = api.someMethod(listener);     emitter.setCancellable(c::close); });
```
    Scheduler:
    create does not operate by default on a particularScheduler.
    Parameters:
    source - the emitter that is called when a CompletableObserver subscribes to the returnedCompletable
    Returns:
    the new Completable instance
    See Also:
    CompletableOnSubscribe,Cancellable
  - unsafeCreate
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable unsafeCreate(CompletableSource source)
```
    Constructs a Completable instance by wrapping the given source callbackwithout any safeguards; you should manage the lifecycle and response to downstream disposal.
    Scheduler:
    unsafeCreate does not operate by default on a particularScheduler.
    Parameters:
    source - the callback which will receive the CompletableObserver instances when the Completable is subscribed to.
    Returns:
    the created Completable instance
    Throws:
    NullPointerException - if source is null
  - defer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable defer(Callable<? extendsCompletableSource> completableSupplier)
```
    Defers the subscription to a Completable instance returned by a supplier.
    Scheduler:
    defer does not operate by default on a particularScheduler.
    Parameters:
    completableSupplier - the supplier that returns the Completable that will be subscribed to.
    Returns:
    the Completable instance
  - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable error(Callable<? extendsThrowable> 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 CompletableObservers will receive a NullPointerException.
    Scheduler:
    error does not operate by default on a particularScheduler.
    Parameters:
    errorSupplier - the error supplier, not null
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if errorSupplier is null
  - error
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable error(Throwable error)
```
    Creates a Completable instance that emits the given Throwable exception to subscribers.
    Scheduler:
    error does not operate by default on a particularScheduler.
    Parameters:
    error - the Throwable instance to emit, not null
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if error is null
  - fromAction
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable fromAction(Action run)
```
    Returns a Completable instance that runs the given Action for each subscriber and emits either an unchecked exception or simply completes.
    Scheduler:
    fromAction does not operate by default on a particularScheduler.
    Error handling:
    If theAction throws an exception, the respectiveThrowable is delivered to the downstream viaCompletableObserver.onError(Throwable), except when the downstream has disposed thisCompletable source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.
    Parameters:
    run - the runnable to run for each subscriber
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if run is null
  - fromCallable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable fromCallable(Callable<?> callable)
```
    Returns a Completable which when subscribed, executes the callable function, ignores its normal result and emits onError or onComplete only.
    Scheduler:
    fromCallable does not operate by default on a particularScheduler.
    Error handling:
    If theCallable throws an exception, the respectiveThrowable is delivered to the downstream viaCompletableObserver.onError(Throwable), except when the downstream has disposed thisCompletable source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.
    Parameters:
    callable - the callable instance to execute for each subscriber
    Returns:
    the new Completable instance
  - fromFuture
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable fromFuture(Future<?> future)
```
    Returns a Completable instance that reacts to the termination of the given Future in a blocking fashion.
    Note that if any of the observers to this Completable call dispose, this Completable will cancel the future.
    Scheduler:
    fromFuture does not operate by default on a particularScheduler.
    Parameters:
    future - the future to react to
    Returns:
    the new Completable instance
  - fromMaybe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Completable fromMaybe(MaybeSource<T> maybe)
```
    Returns a Completable instance that when subscribed to, subscribes to theMaybe instance and emits a completion event if the maybe emitsonSuccess/onComplete or forwards anyonError events.
    Scheduler:
    fromMaybe does not operate by default on a particularScheduler.
    History: 2.1.17 - beta
    Type Parameters:
    T - the value type of theMaybeSource element
    Parameters:
    maybe - the Maybe instance to subscribe to, not null
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if single is null
    Since:
    2.2
  - fromRunnable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable fromRunnable(Runnable run)
```
    Returns a Completable instance that runs the given Runnable for each subscriber and emits either its exception or simply completes.
    Scheduler:
    fromRunnable does not operate by default on a particularScheduler.
    Error handling:
    If theRunnable throws an exception, the respectiveThrowable is delivered to the downstream viaCompletableObserver.onError(Throwable), except when the downstream has disposed thisCompletable source. In this latter case, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) as anUndeliverableException.
    Parameters:
    run - the runnable to run for each subscriber
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if run is null
  - fromObservable
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Completable fromObservable(ObservableSource<T> observable)
```
    Returns a Completable instance that subscribes to the given Observable, ignores all values and emits only the terminal event.
    Scheduler:
    fromObservable does not operate by default on a particularScheduler.
    Type Parameters:
    T - the type of the Observable
    Parameters:
    observable - the Observable instance to subscribe to, not null
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if flowable is null
  - fromPublisher
```
@CheckReturnValue@NonNull@BackpressureSupport(value=UNBOUNDED_IN)@SchedulerSupport(value="none")public static <T> Completable fromPublisher(Publisher<T> publisher)
```
    Returns a Completable instance that subscribes to the given publisher, ignores all values and emits only the terminal event.
    ThePublisher must follow theReactive Streams specification. Violating the specification may result in undefined behavior.
    If possible, usecreate(CompletableOnSubscribe) to create a source-likeCompletable instead.
    Note that even thoughPublisher appears to be a functional interface, it is not recommended to implement it through a lambda as the specification requires state management that is not achievable with a stateless lambda.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    fromPublisher does not operate by default on a particularScheduler.
    Type Parameters:
    T - the type of the publisher
    Parameters:
    publisher - the Publisher instance to subscribe to, not null
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if publisher is null
    See Also:
    create(CompletableOnSubscribe)
  - fromSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <T> Completable fromSingle(SingleSource<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.
    Scheduler:
    fromSingle does not operate by default on a particularScheduler.
    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:
    NullPointerException - if single is null
  - mergeArray
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable mergeArray(CompletableSource... 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.
    Scheduler:
    mergeArray does not operate by default on a particularScheduler.
    Error handling:
    If any of the sourceCompletableSources signal aThrowable viaonError, the resultingCompletable terminates with thatThrowable and all other sourceCompletableSources are disposed. If more than oneCompletableSource signals an error, the resultingCompletable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedCompletable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeArrayDelayError(CompletableSource...) to merge sources and terminate only when all sourceCompletableSources have completed or failed with an error.
    Parameters:
    sources - the iterable sequence of sources.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
    See Also:
    mergeArrayDelayError(CompletableSource...)
  - merge
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable merge(Iterable<? extendsCompletableSource> 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.
    Scheduler:
    merge does not operate by default on a particularScheduler.
    Error handling:
    If any of the sourceCompletableSources signal aThrowable viaonError, the resultingCompletable terminates with thatThrowable and all other sourceCompletableSources are disposed. If more than oneCompletableSource signals an error, the resultingCompletable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedCompletable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Iterable) to merge sources and terminate only when all sourceCompletableSources have completed or failed with an error.
    Parameters:
    sources - the iterable sequence of sources.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
    See Also:
    mergeDelayError(Iterable)
  - merge
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=UNBOUNDED_IN)public static Completable merge(Publisher<? extendsCompletableSource> 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.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    merge does not operate by default on a particularScheduler.
    Error handling:
    If any of the sourceCompletableSources signal aThrowable viaonError, the resultingCompletable terminates with thatThrowable and all other sourceCompletableSources are disposed. If more than oneCompletableSource signals an error, the resultingCompletable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedCompletable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher) to merge sources and terminate only when all sourceCompletableSources have completed or failed with an error.
    Parameters:
    sources - the iterable sequence of sources.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
    See Also:
    mergeDelayError(Publisher)
  - merge
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public static Completable merge(Publisher<? extendsCompletableSource> 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.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    merge does not operate by default on a particularScheduler.
    Error handling:
    If any of the sourceCompletableSources signal aThrowable viaonError, the resultingCompletable terminates with thatThrowable and all other sourceCompletableSources are disposed. If more than oneCompletableSource signals an error, the resultingCompletable may terminate with the first one's error or, depending on the concurrency of the sources, may terminate with aCompositeException containing two or more of the various error signals.Throwables that didn't make into the composite will be sent (individually) to the global error handler viaRxJavaPlugins.onError(Throwable) method asUndeliverableException errors. Similarly,Throwables signaled by source(s) after the returnedCompletable has been disposed or terminated with a (composite) error will be sent to the same global error handler. UsemergeDelayError(Publisher, int) to merge sources and terminate only when all sourceCompletableSources have completed or failed with an error.
    Parameters:
    sources - the iterable sequence of sources.
    maxConcurrency - the maximum number of concurrent subscriptions
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
    IllegalArgumentException - if maxConcurrency is less than 1
    See Also:
    mergeDelayError(Publisher, int)
  - mergeArrayDelayError
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable mergeArrayDelayError(CompletableSource... sources)
```
    Returns a CompletableConsumable 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.
    Scheduler:
    mergeArrayDelayError does not operate by default on a particularScheduler.
    Parameters:
    sources - the array of Completables
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable mergeDelayError(Iterable<? extendsCompletableSource> 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.
    Scheduler:
    mergeDelayError does not operate by default on a particularScheduler.
    Parameters:
    sources - the sequence of Completables
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=UNBOUNDED_IN)public static Completable mergeDelayError(Publisher<? extendsCompletableSource> 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.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    mergeDelayError does not operate by default on a particularScheduler.
    Parameters:
    sources - the sequence of Completables
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
  - mergeDelayError
```
@CheckReturnValue@SchedulerSupport(value="none")@BackpressureSupport(value=FULL)public static Completable mergeDelayError(Publisher<? extendsCompletableSource> 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.
    Backpressure:
    The returnedCompletable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    mergeDelayError does not operate by default on a particularScheduler.
    Parameters:
    sources - the sequence of Completables
    maxConcurrency - the maximum number of concurrent subscriptions to Completables
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if sources is null
  - never
```
@CheckReturnValue@SchedulerSupport(value="none")public static Completable never()
```
    Returns a Completable that never calls onError or onComplete.
    Scheduler:
    never does not operate by default on a particularScheduler.
    Returns:
    the singleton instance that never calls onError or onComplete
  - timer
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public static Completable timer(long delay,TimeUnit unit)
```
    Returns a Completable instance that fires its onComplete event after the given delay elapsed.
    Scheduler:
    timer does operate by default on thecomputationScheduler.
    Parameters:
    delay - the delay time
    unit - the delay unit
    Returns:
    the new Completable instance
  - timer
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public static Completable timer(long delay,TimeUnit unit,Scheduler scheduler)
```
    Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied scheduler.
    Scheduler:
    timer operates on theScheduler you specify.
    Parameters:
    delay - the delay time
    unit - the delay unit
    scheduler - the scheduler where to emit the complete event
    Returns:
    the new Completable instance
  - using
```
@CheckReturnValue@SchedulerSupport(value="none")public static <R> Completable using(Callable<R> resourceSupplier,Function<? super R,? extendsCompletableSource> 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 disposes eagerly before the terminal event is emitted.
    Scheduler:
    using does not operate by default on a particularScheduler.
    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
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static <R> Completable using(Callable<R> resourceSupplier,Function<? super R,? extendsCompletableSource> 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 disposal after the terminal event is emitted. Exceptions thrown at this time will be delivered to RxJavaPlugins only.
    Scheduler:
    using does not operate by default on a particularScheduler.
    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
  - wrap
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public static Completable wrap(CompletableSource source)
```
    Wraps the given CompletableSource into a Completable if not already Completable.
    Scheduler:
    wrap does not operate by default on a particularScheduler.
    Parameters:
    source - the source to wrap
    Returns:
    the source or its wrapper Completable
    Throws:
    NullPointerException - if source is null
  - ambWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable ambWith(CompletableSource other)
```
    Returns a Completable that emits the a terminated event of either this Completable or the other Completable whichever fires first.
    Scheduler:
    ambWith does not operate by default on a particularScheduler.
    Parameters:
    other - the other Completable, not null. A subscription to this provided source will occur after subscribing to the current source.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if other is null
  - andThen
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <T> Observable<T> andThen(ObservableSource<T> next)
```
    Returns an Observable which will subscribe to this Completable and once that is completed then will subscribe to thenext ObservableSource. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription of the Observable.
    Scheduler:
    andThen does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type of the next ObservableSource
    Parameters:
    next - the Observable to subscribe after this Completable is completed, not null
    Returns:
    Observable that composes this Completable and next
    Throws:
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <T> Flowable<T> andThen(Publisher<T> next)
```
    Returns a Flowable which will subscribe to this Completable and once that is completed then will subscribe to thenext Flowable. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription of the Publisher.
    Backpressure:
    The returnedFlowable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    andThen does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type of the next Publisher
    Parameters:
    next - the Publisher to subscribe after this Completable is completed, not null
    Returns:
    Flowable that composes this Completable and next
    Throws:
    NullPointerException - if next is null
  - andThen
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <T> Single<T> andThen(SingleSource<T> next)
```
    Returns a Single which will subscribe to this Completable and once that is completed then will subscribe to thenext SingleSource. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription of the Single.
    Scheduler:
    andThen does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type of the next SingleSource
    Parameters:
    next - the Single to subscribe after this Completable is completed, not null
    Returns:
    Single that composes this Completable and next
  - andThen
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <T> Maybe<T> andThen(MaybeSource<T> next)
```
    Returns aMaybe which will subscribe to this Completable and once that is completed then will subscribe to thenext MaybeSource. An error event from this Completable will be propagated to the downstream subscriber and will result in skipping the subscription of the Maybe.
    Scheduler:
    andThen does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type of the next MaybeSource
    Parameters:
    next - the Maybe to subscribe after this Completable is completed, not null
    Returns:
    Maybe that composes this Completable and next
  - andThen
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable andThen(CompletableSource next)
```
    Returns a Completable that first runs this Completable and then the other completable.
    This is an alias forconcatWith(CompletableSource).
    Scheduler:
    andThen does not operate by default on a particularScheduler.
    Parameters:
    next - the other Completable, not null
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if other is null
  - as
```
@CheckReturnValue@SchedulerSupport(value="none")public final <R> R as(@NonNullCompletableConverter<? extends R> converter)
```
    Calls the specified converter function during assembly time and returns its resulting value.
    This allows fluent conversion to any other type.
    Scheduler:
    as does not operate by default on a particularScheduler.
    History: 2.1.7 - experimental
    Type Parameters:
    R - the resulting object type
    Parameters:
    converter - the function that receives the current Completable instance and returns a value
    Returns:
    the converted value
    Throws:
    NullPointerException - if converter is null
    Since:
    2.2
  - blockingAwait
```
@SchedulerSupport(value="none")public final void blockingAwait()
```
    Subscribes to and awaits the termination of this Completable instance in a blocking manner and rethrows any exception emitted.
    Scheduler:
    blockingAwait does not operate by default on a particularScheduler.
    Error handling:
    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
    Throws:
    RuntimeException - wrapping an InterruptedException if the current thread is interrupted
  - blockingAwait
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final boolean blockingAwait(long timeout,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.
    Scheduler:
    blockingAwait does not operate by default on a particularScheduler.
    Error handling:
    If the source signals an error, the operator wraps a checkedException intoRuntimeException and throws that. Otherwise,RuntimeExceptions andErrors are rethrown as they are.
    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 elapsed before this Completable terminated.
    Throws:
    RuntimeException - wrapping an InterruptedException if the current thread is interrupted
  - blockingGet
```
@Nullable@CheckReturnValue@SchedulerSupport(value="none")public final Throwable blockingGet()
```
    Subscribes to this Completable instance and blocks until it terminates, then returns null or the emitted exception if any.
    Scheduler:
    blockingGet does not operate by default on a particularScheduler.
    Returns:
    the throwable if this terminated with an error, null otherwise
    Throws:
    RuntimeException - that wraps an InterruptedException if the wait is interrupted
  - blockingGet
```
@Nullable@CheckReturnValue@SchedulerSupport(value="none")public final Throwable blockingGet(long timeout,TimeUnit unit)
```
    Subscribes to this Completable instance and blocks until it terminates or the specified timeout elapses, then returns null for normal termination or the emitted exception if any.
    Scheduler:
    blockingGet does not operate by default on a particularScheduler.
    Parameters:
    timeout - the timeout value
    unit - the time unit
    Returns:
    the throwable if this terminated with an error, null otherwise
    Throws:
    RuntimeException - that wraps an InterruptedException if the wait is interrupted or TimeoutException if the specified timeout elapsed before it
  - cache
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable cache()
```
    Subscribes to this Completable only once, when the first CompletableObserver subscribes to the result Completable, caches its terminal event and relays/replays it to observers.
    Note that this operator doesn't allow disposing the connection of the upstream source.
    Scheduler:
    cache does not operate by default on a particularScheduler.
    History: 2.0.4 - experimental
    Returns:
    the new Completable instance
    Since:
    2.1
  - compose
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable compose(CompletableTransformer transformer)
```
    Calls the given transformer function with this instance and returns the function's resulting Completable.
    Scheduler:
    compose does not operate by default on a particularScheduler.
    Parameters:
    transformer - the transformer function, not null
    Returns:
    the Completable returned by the function
    Throws:
    NullPointerException - if transformer is null
  - concatWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable concatWith(CompletableSource other)
```
    Concatenates this Completable with another Completable.
    Scheduler:
    concatWith does not operate by default on a particularScheduler.
    Parameters:
    other - the other Completable, not null
    Returns:
    the new Completable which subscribes to this and then the other Completable
    Throws:
    NullPointerException - if other is null
    See Also:
    andThen(MaybeSource),andThen(ObservableSource),andThen(SingleSource),andThen(Publisher)
  - delay
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Completable delay(long delay,TimeUnit unit)
```
    Returns a Completable which delays the emission of the completion event by the given time.
    Scheduler:
    delay does operate by default on thecomputationScheduler.
    Parameters:
    delay - the delay time
    unit - the delay unit
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if unit is null
  - delay
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Completable delay(long delay,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.
    Scheduler:
    delay operates on theScheduler you specify.
    Parameters:
    delay - the delay time
    unit - the delay unit
    scheduler - the scheduler to run the delayed completion on
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if unit or scheduler is null
  - delay
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Completable delay(long delay,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.
    Scheduler:
    delay operates on theScheduler you specify.
    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:
    NullPointerException - if unit or scheduler is null
  - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Completable delaySubscription(long delay,TimeUnit unit)
```
    Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time.
    Scheduler:
    This version ofdelaySubscription operates by default on thecomputationScheduler.
    Parameters:
    delay - the time to delay the subscription
    unit - the time unit ofdelay
    Returns:
    a Completable that delays the subscription to the source CompletableSource by the given amount
    Since:
    2.2.3 - experimental
    See Also:
    ReactiveX operators documentation: Delay
  - delaySubscription
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Completable delaySubscription(long delay,TimeUnit unit,Scheduler scheduler)
```
    Returns a Completable that delays the subscription to the source CompletableSource by a given amount of time, both waiting and subscribing on a given Scheduler.
    Scheduler:
    You specify whichScheduler this operator will use.
    Parameters:
    delay - the time to delay the subscription
    unit - the time unit ofdelay
    scheduler - the Scheduler on which the waiting and subscription will happen
    Returns:
    a Completable that delays the subscription to the source CompletableSource by a given amount, waiting and subscribing on the given Scheduler
    Since:
    2.2.3 - experimental
    See Also:
    ReactiveX operators documentation: Delay
  - doOnComplete
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable doOnComplete(Action onComplete)
```
    Returns a Completable which calls the given onComplete callback if this Completable completes.
    Scheduler:
    doOnComplete does not operate by default on a particularScheduler.
    Parameters:
    onComplete - the callback to call when this emits an onComplete event
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if onComplete is null
    See Also:
    doFinally(Action)
  - doOnDispose
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable doOnDispose(Action onDispose)
```
    Calls the sharedAction if a CompletableObserver subscribed to the current Completable disposes the common Disposable it received via onSubscribe.
    Scheduler:
    doOnDispose does not operate by default on a particularScheduler.
    Parameters:
    onDispose - the action to call when the child subscriber disposes the subscription
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if onDispose is null
  - doOnError
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable doOnError(Consumer<? superThrowable> onError)
```
    Returns a Completable which calls the given onError callback if this Completable emits an error.
    Scheduler:
    doOnError does not operate by default on a particularScheduler.
    Parameters:
    onError - the error callback
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if onError is null
    See Also:
    doFinally(Action)
  - doOnEvent
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable doOnEvent(Consumer<? superThrowable> onEvent)
```
    Returns a Completable which calls the given onEvent callback with the (throwable) for an onError or (null) for an onComplete signal from this Completable before delivering said signal to the downstream.
    Scheduler:
    doOnEvent does not operate by default on a particularScheduler.
    Parameters:
    onEvent - the event callback
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if onEvent is null
  - doOnSubscribe
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable doOnSubscribe(Consumer<? superDisposable> onSubscribe)
```
    Returns a Completable instance that calls the given onSubscribe callback with the disposable that child subscribers receive on subscription.
    Scheduler:
    doOnSubscribe does not operate by default on a particularScheduler.
    Parameters:
    onSubscribe - the callback called when a child subscriber subscribes
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if onSubscribe is null
  - doOnTerminate
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable doOnTerminate(Action onTerminate)
```
    Returns a Completable instance that calls the given onTerminate callback just before this Completable completes normally or with an exception.
    Scheduler:
    doOnTerminate does not operate by default on a particularScheduler.
    Parameters:
    onTerminate - the callback to call just before this Completable terminates
    Returns:
    the new Completable instance
    See Also:
    doFinally(Action)
  - doAfterTerminate
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable doAfterTerminate(Action onAfterTerminate)
```
    Returns a Completable instance that calls the given onTerminate callback after this Completable completes normally or with an exception.
    Scheduler:
    doAfterTerminate does not operate by default on a particularScheduler.
    Parameters:
    onAfterTerminate - the callback to call after this Completable terminates
    Returns:
    the new Completable instance
    See Also:
    doFinally(Action)
  - doFinally
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable doFinally(Action onFinally)
```
    Calls the specified action after this Completable signals onError or onComplete or gets disposed by the downstream.
    In case of a race between a terminal event and a dispose call, the providedonFinally action is executed once per subscription.
    Note that theonFinally action is shared between subscriptions and as such should be thread-safe.
    Scheduler:
    doFinally does not operate by default on a particularScheduler.
    History: 2.0.1 - experimental
    Parameters:
    onFinally - the action called when this Completable terminates or gets disposed
    Returns:
    the new Completable instance
    Since:
    2.1
  - lift
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable lift(CompletableOperator onLift)
```
    This method requires advanced knowledge about building operators, please consider other standard composition methods first; Returns aCompletable which, when subscribed to, invokes theapply(CompletableObserver) method of the providedCompletableOperator for each individual downstreamCompletable and allows the insertion of a custom operator by accessing the downstream'sCompletableObserver during this subscription phase and providing a newCompletableObserver, containing the custom operator's intended business logic, that will be used in the subscription process going further upstream.
    Generally, such a newCompletableObserver will wrap the downstream'sCompletableObserver and forwards theonError andonComplete events from the upstream directly or according to the emission pattern the custom operator's business logic requires. In addition, such operator can intercept the flow control calls ofdispose andisDisposed that would have traveled upstream and perform additional actions depending on the same business logic requirements.
    Example:
```
 // Step 1: Create the consumer type that will be returned by the CompletableOperator.apply():  public final class CustomCompletableObserver implements CompletableObserver, Disposable {     // The downstream's CompletableObserver that will receive the onXXX events     final CompletableObserver downstream;     // The connection to the upstream source that will call this class' onXXX methods     Disposable upstream;     // The constructor takes the downstream subscriber and usually any other parameters     public CustomCompletableObserver(CompletableObserver downstream) {         this.downstream = downstream;     }     // In the subscription phase, the upstream sends a Disposable to this class     // and subsequently this class has to send a Disposable to the downstream.     // Note that relaying the upstream's Disposable directly is not allowed in RxJava     @Override     public void onSubscribe(Disposable d) {         if (upstream != null) {             d.dispose();         } else {             upstream = d;             downstream.onSubscribe(this);         }     }     // Some operators may handle the upstream's error while others     // could just forward it to the downstream.     @Override     public void onError(Throwable throwable) {         downstream.onError(throwable);     }     // When the upstream completes, usually the downstream should complete as well.     // In completable, this could also mean doing some side-effects     @Override     public void onComplete() {         System.out.println("Sequence completed");         downstream.onComplete();     }     // Some operators may use their own resources which should be cleaned up if     // the downstream disposes the flow before it completed. Operators without     // resources can simply forward the dispose to the upstream.     // In some cases, a disposed flag may be set by this method so that other parts     // of this class may detect the dispose and stop sending events     // to the downstream.     @Override     public void dispose() {         upstream.dispose();     }     // Some operators may simply forward the call to the upstream while others     // can return the disposed flag set in dispose().     @Override     public boolean isDisposed() {         return upstream.isDisposed();     } } // Step 2: Create a class that implements the CompletableOperator interface and //         returns the custom consumer type from above in its apply() method. //         Such class may define additional parameters to be submitted to //         the custom consumer type. final class CustomCompletableOperator implements CompletableOperator {     @Override     public CompletableObserver apply(CompletableObserver upstream) {         return new CustomCompletableObserver(upstream);     } } // Step 3: Apply the custom operator via lift() in a flow by creating an instance of it //         or reusing an existing one. Completable.complete() .lift(new CustomCompletableOperator()) .test() .assertResult();
```
    Creating custom operators can be complicated and it is recommended one consults theRxJava wiki: Writing operators page about the tools, requirements, rules, considerations and pitfalls of implementing them.
    Note that implementing custom operators via thislift() method adds slightly more overhead by requiring an additional allocation and indirection per assembled flows. Instead, extending the abstractCompletable class and creating aCompletableTransformer with it is recommended.
    Note also that it is not possible to stop the subscription phase inlift() as theapply() method requires a non-nullCompletableObserver instance to be returned, which is then unconditionally subscribed to the upstreamCompletable. For example, if the operator decided there is no reason to subscribe to the upstream source because of some optimization possibility or a failure to prepare the operator, it still has to return aCompletableObserver that should immediately dispose the upstream'sDisposable in itsonSubscribe method. Again, using aCompletableTransformer and extending theCompletable is a better option assubscribeActual(io.reactivex.CompletableObserver) can decide to not subscribe to its upstream after all.
    Scheduler:
    lift does not operate by default on a particularScheduler, however, theCompletableOperator may use aScheduler to support its own asynchronous behavior.
    Parameters:
    onLift - theCompletableOperator that receives the downstream'sCompletableObserver and should return aCompletableObserver with custom behavior to be used as the consumer for the currentCompletable.
    Returns:
    the new Completable instance
    See Also:
    RxJava wiki: Writing operators,compose(CompletableTransformer)
  - materialize
```
@CheckReturnValue@SchedulerSupport(value="none")public final <T> Single<Notification<T>> materialize()
```
    Maps the signal types of this Completable into aNotification of the same kind and emits it as a single success value to downstream.
    Scheduler:
    materialize does not operate by default on a particularScheduler.
    Type Parameters:
    T - the intended target element type of the notification
    Returns:
    the new Single instance
    Since:
    2.2.4 - experimental
    See Also:
    Single.dematerialize(Function)
  - mergeWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable mergeWith(CompletableSource other)
```
    Returns a Completable which subscribes to this and the other Completable and completes when both of them complete or one emits an error.
    Scheduler:
    mergeWith does not operate by default on a particularScheduler.
    Parameters:
    other - the other Completable instance
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if other is null
  - observeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Completable observeOn(Scheduler scheduler)
```
    Returns a Completable which emits the terminal events from the thread of the specified scheduler.
    Scheduler:
    observeOn operates on aScheduler you specify.
    Parameters:
    scheduler - the scheduler to emit terminal events on
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if scheduler is null
  - onErrorComplete
```
@CheckReturnValue@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.
    Scheduler:
    onErrorComplete does not operate by default on a particularScheduler.
    Returns:
    the new Completable instance
  - onErrorComplete
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable onErrorComplete(Predicate<? superThrowable> 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.
    Scheduler:
    onErrorComplete does not operate by default on a particularScheduler.
    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
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable onErrorResumeNext(Function<? superThrowable,? extendsCompletableSource> 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.
    Scheduler:
    onErrorResumeNext does not operate by default on a particularScheduler.
    Parameters:
    errorMapper - the mapper function that takes the error and should return a Completable as continuation.
    Returns:
    the new Completable instance
  - onTerminateDetach
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable onTerminateDetach()
```
    Nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose().
    Scheduler:
    onTerminateDetach does not operate by default on a particularScheduler.
    History: 2.1.5 - experimental
    Returns:
    a Completable which nulls out references to the upstream producer and downstream CompletableObserver if the sequence is terminated or downstream calls dispose()
    Since:
    2.2
  - repeat
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable repeat()
```
    Returns a Completable that repeatedly subscribes to this Completable until disposed.
    Scheduler:
    repeat does not operate by default on a particularScheduler.
    Returns:
    the new Completable instance
  - repeat
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable repeat(long times)
```
    Returns a Completable that subscribes repeatedly at most the given times to this Completable.
    Scheduler:
    repeat does not operate by default on a particularScheduler.
    Parameters:
    times - the number of times the resubscription should happen
    Returns:
    the new Completable instance
    Throws:
    IllegalArgumentException - if times is less than zero
  - repeatUntil
```
@CheckReturnValue@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.
    Scheduler:
    repeatUntil does not operate by default on a particularScheduler.
    Parameters:
    stop - the supplier that should return true to stop resubscribing.
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if stop is null
  - repeatWhen
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable repeatWhen(Function<? superFlowable<Object>,? extendsPublisher<?>> 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.
    Scheduler:
    repeatWhen does not operate by default on a particularScheduler.
    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:
    NullPointerException - if stop is null
  - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable retry()
```
    Returns a Completable that retries this Completable as long as it emits an onError event.
    Scheduler:
    retry does not operate by default on a particularScheduler.
    Returns:
    the new Completable instance
  - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable retry(BiPredicate<? superInteger,? superThrowable> predicate)
```
    Returns a Completable that retries this Completable in case of an error as long as the predicate returns true.
    Scheduler:
    retry does not operate by default on a particularScheduler.
    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
```
@CheckReturnValue@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.
    Scheduler:
    retry does not operate by default on a particularScheduler.
    Parameters:
    times - the number of times to resubscribe if the current Completable fails
    Returns:
    the new Completable instance
    Throws:
    IllegalArgumentException - if times is negative
  - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable retry(long times,Predicate<? superThrowable> predicate)
```
    Returns a Completable that when this Completable emits an error, retries at most times or until the predicate returns false, whichever happens first and emitting the last error.
    Scheduler:
    retry does not operate by default on a particularScheduler.
    History: 2.1.8 - experimental
    Parameters:
    times - the number of times to resubscribe if the current Completable fails
    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:
    NullPointerException - if predicate is null
    IllegalArgumentException - if times is negative
    Since:
    2.2
  - retry
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable retry(Predicate<? superThrowable> 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.
    Scheduler:
    retry does not operate by default on a particularScheduler.
    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:
    NullPointerException - if predicate is null
  - retryWhen
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable retryWhen(Function<? superFlowable<Throwable>,? extendsPublisher<?>> handler)
```
    Returns a Completable which given a Publisher and when this Completable emits an error, delivers that error through a Flowable and the Publisher should signal a value indicating a retry in response or a terminal event indicating a termination.
    Note that the innerPublisher returned by the handler function should signal eitheronNext,onError oronComplete in response to the receivedThrowable to indicate the operator should retry or terminate. If the upstream to the operator is asynchronous, signalling onNext followed by onComplete immediately may result in the sequence to be completed immediately. Similarly, if this innerPublisher signalsonError oronComplete while the upstream is active, the sequence is terminated with the same signal immediately.
    The following example demonstrates how to retry an asynchronous source with a delay:
```
 Completable.timer(1, TimeUnit.SECONDS)     .doOnSubscribe(s -> System.out.println("subscribing"))     .doOnComplete(() -> { throw new RuntimeException(); })     .retryWhen(errors -> {         AtomicInteger counter = new AtomicInteger();         return errors                   .takeWhile(e -> counter.getAndIncrement() != 3)                   .flatMap(e -> {                       System.out.println("delay retry by " + counter.get() + " second(s)");                       return Flowable.timer(counter.get(), TimeUnit.SECONDS);                   });     })     .blockingAwait();
```
    Scheduler:
    retryWhen does not operate by default on a particularScheduler.
    Parameters:
    handler - the handler that receives a Flowable 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:
    NullPointerException - if handler is null
  - startWith
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable startWith(CompletableSource other)
```
    Returns a Completable which first runs the other Completable then this completable if the other completed normally.
    Scheduler:
    startWith does not operate by default on a particularScheduler.
    Parameters:
    other - the other completable to run first
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if other is null
  - startWith
```
@CheckReturnValue@NonNull@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 CompletableConsumable.
    Scheduler:
    startWith does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Parameters:
    other - the other Observable to run first
    Returns:
    the new Observable instance
    Throws:
    NullPointerException - if other is null
  - startWith
```
@CheckReturnValue@NonNull@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <T> Flowable<T> startWith(Publisher<T> other)
```
    Returns a Flowable which first delivers the events of the other Publisher then runs this Completable.
    Backpressure:
    The returnedFlowable honors the backpressure of the downstream consumer and expects the otherPublisher to honor it as well.
    Scheduler:
    startWith does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Parameters:
    other - the other Publisher to run first
    Returns:
    the new Flowable instance
    Throws:
    NullPointerException - if other is null
  - hide
```
@CheckReturnValue@SchedulerSupport(value="none")public final Completable hide()
```
    Hides the identity of this Completable and its Disposable.
    Allows preventing certain identity-based optimizations (fusion).
    Scheduler:
    hide does not operate by default on a particularScheduler.
    History: 2.0.5 - experimental
    Returns:
    the new Completable instance
    Since:
    2.1
  - subscribe
```
@SchedulerSupport(value="none")public final Disposable subscribe()
```
    Subscribes to this CompletableConsumable and returns a Disposable which can be used to dispose the subscription.
    Scheduler:
    subscribe does not operate by default on a particularScheduler.
    Returns:
    the Disposable that allows disposing the subscription
  - subscribe
```
@SchedulerSupport(value="none")public final void subscribe(CompletableObserver observer)
```
    Description copied from interface: CompletableSource
    Subscribes the given CompletableObserver to this CompletableSource instance.
    Specified by:
    subscribe in interface CompletableSource
    Parameters:
    observer - the CompletableObserver, not null
  - subscribeActual
```
protected abstract void subscribeActual(CompletableObserver observer)
```
    Implement this method to handle the incomingCompletableObservers and perform the business logic in your operator.
    There is no need to call any of the plugin hooks on the currentCompletable instance or theCompletableObserver; all hooks and basic safeguards have been applied bysubscribe(CompletableObserver) before this method gets called.
    Parameters:
    observer - the CompletableObserver instance, never null
  - subscribeWith
```
@CheckReturnValue@SchedulerSupport(value="none")public final <E extendsCompletableObserver> E subscribeWith(E observer)
```
    Subscribes a given CompletableObserver (subclass) to this Completable and returns the given CompletableObserver as is.
    Usage example:
```
 Completable source = Completable.complete().delay(1, TimeUnit.SECONDS); CompositeDisposable composite = new CompositeDisposable(); DisposableCompletableObserver ds = new DisposableCompletableObserver() {     // ... }; composite.add(source.subscribeWith(ds));
```
    Scheduler:
    subscribeWith does not operate by default on a particularScheduler.
    Type Parameters:
    E - the type of the CompletableObserver to use and return
    Parameters:
    observer - the CompletableObserver (subclass) to use and return, not null
    Returns:
    the inputobserver
    Throws:
    NullPointerException - ifobserver is null
    Since:
    2.0
  - subscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Disposable subscribe(Action onComplete,Consumer<? superThrowable> onError)
```
    Subscribes to this Completable and calls back either the onError or onComplete functions.
    Scheduler:
    subscribe does not operate by default on a particularScheduler.
    Parameters:
    onComplete - the runnable that is called if the Completable completes normally
    onError - the consumer that is called if this Completable emits an error
    Returns:
    the Disposable that can be used for disposing the subscription asynchronously
    Throws:
    NullPointerException - if either callback is null
  - subscribe
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Disposable subscribe(Action onComplete)
```
    Subscribes to this Completable and calls the given Action when this Completable completes normally.
    If the Completable emits an error, it is wrapped into anOnErrorNotImplementedException and routed to the RxJavaPlugins.onError handler.
    Scheduler:
    subscribe does not operate by default on a particularScheduler.
    Parameters:
    onComplete - the runnable called when this Completable completes normally
    Returns:
    the Disposable that allows disposing the subscription
  - subscribeOn
```
@CheckReturnValue@NonNull@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.
    Scheduler:
    subscribeOn operates on aScheduler you specify.
    Parameters:
    scheduler - the Scheduler to subscribe on
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if scheduler is null
  - takeUntil
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final Completable takeUntil(CompletableSource other)
```
    Terminates the downstream if this or the otherCompletable terminates (wins the termination race) while disposing the connection to the losing source.
    Scheduler:
    takeUntil does not operate by default on a particularScheduler.
    Error handling:
    If both this and the other sources signal an error, only one of the errors is signaled to the downstream and the other error is signaled to the global error handler viaRxJavaPlugins.onError(Throwable).
    History: 2.1.17 - experimental
    Parameters:
    other - the other completable source to observe for the terminal signals
    Returns:
    the new Completable instance
    Since:
    2.2
  - timeout
```
@CheckReturnValue@SchedulerSupport(value="io.reactivex:computation")public final Completable timeout(long timeout,TimeUnit unit)
```
    Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time.
    Scheduler:
    timeout signals the TimeoutException on thecomputationScheduler.
    Parameters:
    timeout - the timeout value
    unit - the timeout unit
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if unit is null
  - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="io.reactivex:computation")public final Completable timeout(long timeout,TimeUnit unit,CompletableSource 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.
    Scheduler:
    timeout subscribes to the other CompletableSource on thecomputationScheduler.
    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:
    NullPointerException - if unit or other is null
  - timeout
```
@CheckReturnValue@SchedulerSupport(value="custom")public final Completable timeout(long timeout,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.
    Scheduler:
    timeout signals the TimeoutException on theScheduler you specify.
    Parameters:
    timeout - the timeout value
    unit - the timeout unit
    scheduler - the scheduler to use to wait for completion
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if unit or scheduler is null
  - timeout
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Completable timeout(long timeout,TimeUnit unit,Scheduler scheduler,CompletableSource 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.
    Scheduler:
    timeout subscribes to the other CompletableSource on theScheduler you specify.
    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:
    NullPointerException - if unit, scheduler or other is null
  - to
```
@CheckReturnValue@SchedulerSupport(value="none")public final <U> U to(Function<? superCompletable,U> converter)
```
    Allows fluent conversion to another type via a function callback.
    Scheduler:
    to does not operate by default on a particularScheduler.
    Type Parameters:
    U - the output type
    Parameters:
    converter - the function called with this which should return some other value.
    Returns:
    the converted value
    Throws:
    NullPointerException - if converter is null
  - toFlowable
```
@CheckReturnValue@BackpressureSupport(value=FULL)@SchedulerSupport(value="none")public final <T> Flowable<T> toFlowable()
```
    Returns a Flowable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
    Backpressure:
    The returnedFlowable honors the backpressure of the downstream consumer.
    Scheduler:
    toFlowable does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Returns:
    the new Flowable instance
  - toMaybe
```
@CheckReturnValue@SchedulerSupport(value="none")public final <T> Maybe<T> toMaybe()
```
    Converts this Completable into aMaybe.
    Scheduler:
    toMaybe does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Returns:
    aMaybe that only callsonComplete oronError, based on which one is called by the source Completable.
  - toObservable
```
@CheckReturnValue@SchedulerSupport(value="none")public final <T> Observable<T> toObservable()
```
    Returns an Observable which when subscribed to subscribes to this Completable and relays the terminal events to the subscriber.
    Scheduler:
    toObservable does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Returns:
    the new Observable created
  - toSingle
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <T> Single<T> toSingle(Callable<? extends T> completionValueSupplier)
```
    Converts this Completable into a Single which when this Completable completes normally, calls the given supplier and emits its returned value through onSuccess.
    Scheduler:
    toSingle does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Parameters:
    completionValueSupplier - the value supplier called when this Completable completes normally
    Returns:
    the new Single instance
    Throws:
    NullPointerException - if completionValueSupplier is null
  - toSingleDefault
```
@CheckReturnValue@NonNull@SchedulerSupport(value="none")public final <T> Single<T> toSingleDefault(T completionValue)
```
    Converts this Completable into a Single which when this Completable completes normally, emits the given value through onSuccess.
    Scheduler:
    toSingleDefault does not operate by default on a particularScheduler.
    Type Parameters:
    T - the value type
    Parameters:
    completionValue - the value to emit when this Completable completes normally
    Returns:
    the new Single instance
    Throws:
    NullPointerException - if completionValue is null
  - unsubscribeOn
```
@CheckReturnValue@NonNull@SchedulerSupport(value="custom")public final Completable unsubscribeOn(Scheduler scheduler)
```
    Returns a Completable which makes sure when a subscriber disposes the subscription, the dispose is called on the specified scheduler.
    Scheduler:
    unsubscribeOn calls dispose() of the upstream on theScheduler you specify.
    Parameters:
    scheduler - the target scheduler where to execute the disposing
    Returns:
    the new Completable instance
    Throws:
    NullPointerException - if scheduler is null
  - test
```
@CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<Void> test()
```
    Creates a TestObserver and subscribes it to this Completable.
    Scheduler:
    test does not operate by default on a particularScheduler.
    Returns:
    the new TestObserver instance
    Since:
    2.0
  - test
```
@CheckReturnValue@SchedulerSupport(value="none")public final TestObserver<Void> test(boolean cancelled)
```
    Creates a TestObserver optionally in cancelled state, then subscribes it to this Completable.
    Parameters:
    cancelled - if true, the TestObserver will be cancelled before subscribing to this Completable.
    Scheduler:
    test does not operate by default on a particularScheduler.
    Returns:
    the new TestObserver instance
    Since:
    2.0

Movatterモバイル変換

Class Completable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Completable

Method Detail

ambArray

amb

complete

concatArray

concat

concat

concat

create

unsafeCreate

defer

error

error

fromAction

fromCallable

fromFuture

fromMaybe

fromRunnable

fromObservable

fromPublisher

fromSingle

mergeArray

merge

merge

merge

mergeArrayDelayError

mergeDelayError

mergeDelayError

mergeDelayError

never

timer

timer

using

using

wrap

ambWith

andThen

andThen

andThen

andThen

andThen

as

blockingAwait

blockingAwait

blockingGet

blockingGet

cache

compose

concatWith

delay

delay

delay

delaySubscription

delaySubscription

doOnComplete

doOnDispose

doOnError

doOnEvent

doOnSubscribe

doOnTerminate

doAfterTerminate

doFinally

lift

materialize

mergeWith

observeOn

onErrorComplete

onErrorComplete

onErrorResumeNext

onTerminateDetach

repeat

repeat

repeatUntil