Package io.reactivex.rxjava3.internal.operators.single

Class SingleFlatMapIterableFlowable.FlatMapIterableObserver<T,R>

java.lang.Object
java.lang.Number
java.util.concurrent.atomic.AtomicInteger
io.reactivex.rxjava3.internal.subscriptions.BasicIntQueueSubscription<R>
io.reactivex.rxjava3.internal.operators.single.SingleFlatMapIterableFlowable.FlatMapIterableObserver<T,R>
All Implemented Interfaces:
SingleObserver<T>, QueueFuseable<R>, QueueSubscription<R>, SimpleQueue<R>, Serializable, org.reactivestreams.Subscription
Enclosing class:
SingleFlatMapIterableFlowable<T,R>
static final class SingleFlatMapIterableFlowable.FlatMapIterableObserver<T,R> extends BasicIntQueueSubscription<R> implements SingleObserver<T>

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:

    • downstream

      final org.reactivestreams.Subscriber<? super R> downstream

    • mapper

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

    • requested

      final AtomicLong requested

    • upstream

      Disposable upstream

    • it

      volatile Iterator<? extends R> it

    • cancelled

      volatile boolean cancelled

    • outputFused

      boolean outputFused

  • Constructor Details

    • FlatMapIterableObserver

      FlatMapIterableObserver(org.reactivestreams.Subscriber<? super R> actual, Function<? super T,? extends Iterable<? extends R>> mapper)

  • Method Details

    • onSubscribe

      public void onSubscribe(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

    • onSuccess

      public void onSuccess(T value)
      Description copied from interface: SingleObserver
      Notifies the SingleObserver with a single item and that the Single has finished sending push-based notifications.

      The Single will not call this method if it calls SingleObserver.onError(java.lang.Throwable).

      Specified by:
      onSuccess in interface SingleObserver<T>
      Parameters:
      value - the item emitted by the Single

    • onError

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

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

      Specified by:
      onError in interface SingleObserver<T>
      Parameters:
      e - the exception encountered by the Single

    • request

      public void request(long n)
      Specified by:
      request in interface org.reactivestreams.Subscription

    • cancel

      public void cancel()
      Specified by:
      cancel in interface org.reactivestreams.Subscription

    • drain

      void drain()

    • fastPath

      void fastPath(org.reactivestreams.Subscriber<? super R> a, Iterator<? extends R> iterator)

    • 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