Type Members

1.  trait AsPublisher[F[_]] extends AnyRef

   Represents the ability for some type F[_] to be converted to a publisher, in addition to perform some basic algebra on the F[_] (such as collecting into another F[_])

   Represents the ability for some type F[_] to be converted to a publisher, in addition to perform some basic algebra on the F[_] (such as collecting into another F[_])

   F

   the typeclass which can be represented as a publisher

2.  trait AsSubscriber[F[_]] extends AnyRef

   Represents any F[_] which can be represented as a Subscriber

3.  trait AsyncPublisher[T] extends Publisher[T] with StrictLogging with AutoCloseable

   A hot publisher to multiple subscribers, where new subscriptions simply begin observing the messages as the point of subscription.

   A hot publisher to multiple subscribers, where new subscriptions simply begin observing the messages as the point of subscription. Each subscription maintains its own queue, and so slow consumers can end up eating up memory.

   This is quite a basic implementation of a reactive-stream, without real attention to efficiency or performance.

   Consider using the raft-monix, raft-fs2 or raft-akka libraries for a more robust approach.

4.  final class AsyncSubscription[T] extends Subscription with StrictLogging

   Represents a subscription whose actions are handled via a Runnable pulling values from a blocking internalStateInputQueue submitted on a provided execution context

5.  class CollectPublisher[-A, B] extends Publisher[B] with AutoCloseable

   Simple implementation of a publisher which can filter its published elements

6.  class MapPublisher[A, B] extends Publisher[B] with AutoCloseable
7.  trait MultiSubscriberProcessor[A] extends AsyncPublisher[A] with Subscriber[A] with StrictLogging with AutoCloseable

   A 'Processor' (both a subscriber and publisher) which can be subscribed to multiple publishers in order to collate and publish their values.

   A 'Processor' (both a subscriber and publisher) which can be subscribed to multiple publishers in order to collate and publish their values.

   val sub : MultiSubscriberProcessor[A] = ...
   pub1.subscribe(sub)
   pub2.subscribe(sub)
   pub3.subscribe(sub)
   
   // the subscribers to 'sub' will receive the values published from pub1, pub2 and pub3
   sub.subscribe(...)

8.  case class ReactivePipe[In, Out, Sub[_], Pub[_]](input: Sub[In], output: Pub[Out])(implicit evidence$1: AsSubscriber[Sub], evidence$2: AsPublisher[Pub]) extends AutoCloseable with Product with Serializable

   Represents an input/output pipe

9.  class ReactiveTimerCallback extends TimerCallback[TimerMessage] with AsyncPublisher[TimerMessage]

   An implementation of a TimerCallback which publishes TimerMessages

10.  trait ReplayPublisher[A] extends AsyncPublisher[A]

    A publisher which will replay all elements from before any subscription begins

    A publisher which will replay all elements from before any subscription begins

    A

    the type of data which is appended to the log (could just be a byte array, some union type, etc)

11.  trait SingleSubscriber[A] extends Subscriber[A]

    Adds a means to accessing the Subscription when subscribed.

    Adds a means to accessing the Subscription when subscribed.

    The 'onError' will remove the subscription, so overriding classes should implement 'doOnError' for error-handling behvior.