observers

Type Members

1. trait BufferedSubscriber[-T] extends Subscriber[T]

   

   Interface describing Observer wrappers that are thread-safe (can receive concurrent events) and that return an immediate Continue when receiving onNext events.

   Interface describing Observer wrappers that are thread-safe (can receive concurrent events) and that return an immediate Continue when receiving onNext events. Meant to be used by data sources that cannot uphold the no-concurrent events and the back-pressure related requirements (i.e. data-sources that cannot wait on Future[Continue] for sending the next event).

   Implementations of this interface have the following contract:

   • onNext / onError / onComplete of this interface MAY be called concurrently
   • onNext SHOULD return an immediate Continue, as long as the buffer is not full and the underlying observer hasn't signaled Cancel (N.B. due to the asynchronous nature, Cancel signaled by the underlying observer may be noticed later, so implementations of this interface make no guarantee about queued events - which could be generated, queued and dropped on the floor later)
   • onNext MUST return an immediate Cancel result, after it notices that the underlying observer signaled Cancel (due to the asynchronous nature of observers, this may happen later and queued events might get dropped on the floor)
   • in general the contract for the underlying Observer is fully respected (grammar, non-concurrent notifications, etc...)
   • when the underlying observer canceled (by returning Cancel), or when a concurrent upstream data source triggered an error, this SHOULD eventually be noticed and acted upon
   • as long as the buffer isn't full and the underlying observer isn't Cancel, then implementations of this interface SHOULD not lose events in the process
   • the buffer MAY BE either unbounded or bounded, in case of bounded buffers, then an appropriate overflowStrategy needs to be set for when the buffer overflows - either an onError triggered in the underlying observer coupled with a Cancel signaled to the upstream data sources, or dropping events from the head or the tail of the queue, or attempting to apply back-pressure, etc...

   See OverflowStrategy for the buffer policies available.

2. final class CacheUntilConnectSubscriber[-T] extends Subscriber[T]

   

   Wraps an underlying Subscriber into an implementation that caches all events until the call to connect() happens.

   Wraps an underlying Subscriber into an implementation that caches all events until the call to connect() happens. After being connected, the buffer is drained into the underlying observer, after which all subsequent events are pushed directly.

3. final class ConnectableSubscriber[-T] extends Channel[T] with Subscriber[T]

   

   Wraps a Subscriber into an implementation that abstains from emitting items until the call to connect() happens.

   Wraps a Subscriber into an implementation that abstains from emitting items until the call to connect() happens. Prior to connect() it's also a Channel into which you can enqueue events for delivery once connect() happens, but before any items emitted by onNext / onComplete and onError.

   Example:

   val obs = ConnectableObserver(observer)
   
   // schedule onNext event, after connect()
   obs.onNext("c")
   
   // schedule event "a" to be emitted first
   obs.pushNext("a")
   // schedule event "b" to be emitted second
   obs.pushNext("b")
   
   // underlying observer now gets events "a", "b", "c" in order
   obs.connect()

   Example of an observer ended in error:

   val obs = ConnectableObserver(observer)
   
   // schedule onNext event, after connect()
   obs.onNext("c")
   
   obs.pushNext("a") // event "a" to be emitted first
   obs.pushNext("b") // event "b" to be emitted first
   
   // schedule an onError sent downstream, once connect()
   // happens, but after "a" and "b"
   obs.pushError(new RuntimeException())
   
   // underlying observer receives ...
   // onNext("a") -> onNext("b") -> onError(RuntimeException)
   obs.connect()
   
   // NOTE: that onNext("c") never happens

4. final class SafeSubscriber[-T] extends Subscriber[T]

   

   A safe observer ensures too things:

   A safe observer ensures too things:

   - errors triggered by downstream observers are caught and streamed to onError, while the upstream gets an Ack.Cancel, to stop sending events

   - once an onError or onComplete was emitted, the observer no longer accepts onNext events, ensuring that the Rx grammar is respected.

   - if downstream signals a Cancel, the observer no longer accepts any events, ensuring that the Rx grammar is respected.

   This implementation doesn't address multi-threading concerns in any way.

5. trait SynchronousObserver[-T] extends Observer[T]

   

   A SynchronousObserver is an Observer that signals demand to upstream synchronously (i.e.

   A SynchronousObserver is an Observer that signals demand to upstream synchronously (i.e. the upstream observable doesn't need to wait on a Future in order to decide whether to send the next event or not).

   Can be used for optimizations.

6. trait SynchronousSubscriber[-T] extends Subscriber[T] with SynchronousObserver[T]

   

   A SynchronousSubscriber is a Subscriber whose onNext signal is synchronous (i.e.

   A SynchronousSubscriber is a Subscriber whose onNext signal is synchronous (i.e. the upstream observable doesn't need to wait on a Future in order to decide whether to send the next event or not).