Class DisposableSingleObserver<T>

  • Type Parameters:
    T - the received value type
    All Implemented Interfaces:
    SingleObserver<T>, Disposable

    public abstract class DisposableSingleObserver<T>
    extends java.lang.Object
    implements SingleObserver<T>, Disposable
    An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.

    All pre-implemented final methods are thread-safe.

    Like all other consumers, DisposableSingleObserver 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(), SingleObserver.onSuccess(Object) and SingleObserver.onError(Throwable) are not allowed to throw any unchecked exceptions.

    Example

    
     Disposable d =
         Single.just(1).delay(1, TimeUnit.SECONDS)
         .subscribeWith(new DisposableSingleObserver<Integer>() {
             @Override public void onStart() {
                 System.out.println("Start!");
             }
             @Override public void onSuccess(Integer t) {
                 System.out.println(t);
             }
             @Override public void onError(Throwable t) {
                 t.printStackTrace();
             }
         });
     // ...
     d.dispose();
     
    • Field Summary

      Fields 
      Modifier and Type Field Description
      (package private) java.util.concurrent.atomic.AtomicReference<Disposable> upstream  
    • 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)
      Provides the SingleObserver with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • upstream

        final java.util.concurrent.atomic.AtomicReference<Disposable> upstream
    • Constructor Detail

      • DisposableSingleObserver

        public DisposableSingleObserver()
    • Method Detail

      • onSubscribe

        public final void onSubscribe​(@NonNull
                                      @NonNull Disposable d)
        Description copied from interface: SingleObserver
        Provides the SingleObserver with the means of cancelling (disposing) the connection (channel) with the Single in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
        Specified by:
        onSubscribe in interface SingleObserver<T>
        Parameters:
        d - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection
      • 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