DisposableCompletableObserver

java.lang.Object
- io.reactivex.rxjava3.observers.DisposableCompletableObserver

All Implemented Interfaces:

CompletableObserver, Disposable
```
public abstract class DisposableCompletableObserver
extends java.lang.Object
implements CompletableObserver, Disposable
```
An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable.
All pre-implemented final methods are thread-safe.
Like all other consumers, DisposableCompletableObserver can be subscribed only once. Any subsequent attempt to subscribe it to a new source will yield an IllegalStateException with message "It is not allowed to subscribe with a(n) <class name> multiple times.".
Implementation of onStart(), CompletableObserver.onError(Throwable) and CompletableObserver.onComplete() are not allowed to throw any unchecked exceptions.
Example
```
 Disposable d =
     Completable.complete().delay(1, TimeUnit.SECONDS)
     .subscribeWith(new DisposableMaybeObserver<Integer>() {
         @Override public void onStart() {
             System.out.println("Start!");
         }
         @Override public void onError(Throwable t) {
             t.printStackTrace();
         }
         @Override public void onComplete() {
             System.out.println("Done!");
         }
     });
 // ...
 d.dispose();
 
```

Field Summary

Fields
Modifier and Type Field Description

(package private) java.util.concurrent.atomic.AtomicReference<Disposable> upstream

Constructor Summary

Constructors
Constructor Description

DisposableCompletableObserver()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`dispose()`	Dispose the resource, the operation should be idempotent.
`boolean`	`isDisposed()`	Returns true if this resource has been disposed.
`protected void`	`onStart()`	Called once the single upstream `Disposable` is set via `onSubscribe(Disposable)`.
`void`	`onSubscribe(@NonNull Disposable d)`	Called once by the `Completable` to set a `Disposable` on this instance which then can be used to cancel the subscription at any time.

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

Methods inherited from interface io.reactivex.rxjava3.core.CompletableObserver
onComplete, onError

- Field Detail
  - upstream
```
final java.util.concurrent.atomic.AtomicReference<Disposable> upstream
```
- Constructor Detail
  - DisposableCompletableObserver
```
public DisposableCompletableObserver()
```
- Method Detail
  - onSubscribe
```
public final void onSubscribe(@NonNull
                              @NonNull Disposable d)
```
    Description copied from interface: CompletableObserver
    
    Called once by the Completable to set a Disposable on this instance which then can be used to cancel the subscription at any time.
    
    Specified by:
    
    onSubscribe in interface CompletableObserver
    
    Parameters:
    
    d - the Disposable instance to call dispose on for cancellation, not null
  - onStart
```
protected void onStart()
```
    Called once the single upstream Disposable is set via onSubscribe(Disposable).
  - isDisposed
```
public final boolean isDisposed()
```
    Description copied from interface: Disposable
    
    Returns true if this resource has been disposed.
    
    Specified by:
    
    isDisposed in interface Disposable
    
    Returns:
    
    true if this resource has been disposed
  - dispose
```
public final void dispose()
```
    Description copied from interface: Disposable
    
    Dispose the resource, the operation should be idempotent.
    
    Specified by:
    
    dispose in interface Disposable