Class MaybeFlatMapIterableObservable.FlatMapIterableObserver<T,R>

java.lang.Object
io.reactivex.rxjava3.internal.observers.BasicQueueDisposable<R>
io.reactivex.rxjava3.internal.operators.maybe.MaybeFlatMapIterableObservable.FlatMapIterableObserver<T,R>
All Implemented Interfaces:
MaybeObserver<T>, Disposable, QueueDisposable<R>, QueueFuseable<R>, SimpleQueue<R>
Enclosing class:
MaybeFlatMapIterableObservable<T,R>
static final class MaybeFlatMapIterableObservable.FlatMapIterableObserver<T,R> extends BasicQueueDisposable<R> implements MaybeObserver<T>

  • Field Details

    • downstream

      final Observer<? super R> downstream

    • mapper

      final Function<? super T, ? extends Iterable<? extends R>> mapper

    • upstream

      Disposable upstream

    • it

      volatile Iterator<? extends R> it

    • cancelled

      volatile boolean cancelled

    • outputFused

      boolean outputFused

  • Constructor Details

    • FlatMapIterableObserver

      FlatMapIterableObserver(Observer<? super R> actual, Function<? super T, ? extends Iterable<? extends R>> mapper)

  • Method Details

    • onSubscribe

      public void onSubscribe(Disposable d)
      Description copied from interface: MaybeObserver
      Provides the MaybeObserver with the means of cancelling (disposing) the connection (channel) with the Maybe in both synchronous (from within onSubscribe(Disposable) itself) and asynchronous manner.
      Specified by:
      onSubscribe in interface MaybeObserver<T>
      Parameters:
      d - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection

    • onSuccess

      public void onSuccess(T value)
      Description copied from interface: MaybeObserver
      Notifies the MaybeObserver with one item and that the Maybe has finished sending push-based notifications.

      The Maybe will not call this method if it calls MaybeObserver.onError(Throwable).

      Specified by:
      onSuccess in interface MaybeObserver<T>
      Parameters:
      value - the item emitted by the Maybe

    • onError

      public void onError(Throwable e)
      Description copied from interface: MaybeObserver
      Notifies the MaybeObserver that the Maybe has experienced an error condition.

      If the Maybe calls this method, it will not thereafter call MaybeObserver.onSuccess(T).

      Specified by:
      onError in interface MaybeObserver<T>
      Parameters:
      e - the exception encountered by the Maybe

    • onComplete

      public void onComplete()
      Description copied from interface: MaybeObserver
      Called once the deferred computation completes normally.
      Specified by:
      onComplete in interface MaybeObserver<T>

    • dispose

      public void dispose()
      Description copied from interface: Disposable
      Dispose the resource, the operation should be idempotent.
      Specified by:
      dispose in interface Disposable

    • isDisposed

      public 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

    • requestFusion

      public int requestFusion(int mode)
      Description copied from interface: QueueFuseable
      Request a fusion mode from the upstream.

      This should be called before onSubscribe returns.

      Calling this method multiple times or after onSubscribe finished is not allowed and may result in undefined behavior.

      Specified by:
      requestFusion in interface QueueFuseable<T>
      Parameters:
      mode - the requested fusion mode, allowed values are QueueFuseable.SYNC, QueueFuseable.ASYNC, QueueFuseable.ANY combined with QueueFuseable.BOUNDARY (e.g., requestFusion(SYNC | BOUNDARY)).
      Returns:
      the established fusion mode: QueueFuseable.NONE, QueueFuseable.SYNC, QueueFuseable.ASYNC.

    • clear

      public void clear()
      Description copied from interface: SimpleQueue
      Removes all enqueued items from this queue.
      Specified by:
      clear in interface SimpleQueue<T>

    • isEmpty

      public boolean isEmpty()
      Description copied from interface: SimpleQueue
      Returns true if the queue is empty.

      Note however that due to potential fused functions in SimpleQueue.poll() it is possible this method returns false but then poll() returns null because the fused function swallowed the available item(s).

      Specified by:
      isEmpty in interface SimpleQueue<T>
      Returns:
      true if the queue is empty

    • poll

      @Nullable public R poll()
      Description copied from interface: SimpleQueue
      Tries to dequeue a value (non-null) or returns null if the queue is empty.

      If the producer uses SimpleQueue.offer(Object, Object) and when polling in pairs, if the first poll() returns a non-null item, the second poll() is guaranteed to return a non-null item as well.

      Specified by:
      poll in interface SimpleQueue<T>
      Returns:
      the item or null to indicate an empty queue