object ConcurrentSubject extends Serializable
- Source
- ConcurrentSubject.scala
- Alphabetic
- By Inheritance
- ConcurrentSubject
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- def apply[A](multicast: MulticastStrategy[A], overflow: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
- def apply[A](multicast: MulticastStrategy[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
- def async[A](implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building async subjects.
- def behavior[A](initial: A, strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building behavior subjects.
Subject recipe for building behavior subjects.
- initial
the initial element to emit on subscribe, before the first
onNexthappens- strategy
the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def behavior[A](initial: A)(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building behavior subjects.
Subject recipe for building behavior subjects.
- initial
the initial element to emit on subscribe, before the first
onNexthappens
- def from[I, O](p: Subject[I, O], overflowStrategy: Synchronous[I], producerType: ProducerSide = MultiProducer)(implicit s: Scheduler): ConcurrentSubject[I, O]
Wraps any Subject into a ConcurrentSubject.
Wraps any Subject into a ConcurrentSubject.
- overflowStrategy
- the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- producerType
(UNSAFE) is the monix.execution.ChannelType.ProducerSide configuration, can be either multi producer (the safe default) or single producer, which can be configured for optimization purposes.
- def publish[A](strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building publish subjects.
Subject recipe for building publish subjects.
- strategy
- the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def publish[A](implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building publish subjects.
- def publishToOne[A](strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building PublishToOneSubject.
Subject recipe for building PublishToOneSubject.
- strategy
- the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def publishToOne[A](implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building PublishToOneSubject.
- def replay[A](initial: Seq[A], strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects.
- initial
is an initial sequence of elements that will be pushed to subscribers before any elements emitted by the source.
- strategy
the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def replay[A](initial: Seq[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects.
- initial
is an initial sequence of elements that will be pushed to subscribers before any elements emitted by the source.
- def replay[A](strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects.
- strategy
the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def replay[A](implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
- def replayLimited[A](capacity: Int, initial: Seq[A], strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects. This variant creates a size-bounded replay subject.
In this setting, the replay subject with a maximum capacity for its internal buffer and discards the oldest item. The
capacitygiven is a guideline. The underlying implementation may decide to optimize it (e.g. use the next power of 2 greater or equal to the given value).- capacity
indicates the minimum capacity of the underlying buffer, with the implementation being free to increase it.
- initial
is an initial sequence of elements to prepopulate the buffer.
- strategy
the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def replayLimited[A](capacity: Int, initial: Seq[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects. This variant creates a size-bounded replay subject.
In this setting, the replay subject with a maximum capacity for its internal buffer and discards the oldest item. The
capacitygiven is a guideline. The underlying implementation may decide to optimize it (e.g. use the next power of 2 greater or equal to the given value).- capacity
indicates the minimum capacity of the underlying buffer, with the implementation being free to increase it.
- initial
is an initial sequence of elements to prepopulate the buffer.
- def replayLimited[A](capacity: Int, strategy: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects. This variant creates a size-bounded replay subject.
In this setting, the replay subject with a maximum capacity for its internal buffer and discards the oldest item. The
capacitygiven is a guideline. The underlying implementation may decide to optimize it (e.g. use the next power of 2 greater or equal to the given value).- capacity
indicates the minimum capacity of the underlying buffer, with the implementation being free to increase it.
- strategy
the overflow strategy used for buffering, which specifies what to do in case we're dealing with slow consumers.
- def replayLimited[A](capacity: Int)(implicit s: Scheduler): ConcurrentSubject[A, A]
Subject recipe for building replay subjects.
Subject recipe for building replay subjects. This variant creates a size-bounded replay subject.
In this setting, the replay subject with a maximum capacity for its internal buffer and discards the oldest item. The
capacitygiven is a guideline. The underlying implementation may decide to optimize it (e.g. use the next power of 2 greater or equal to the given value).- capacity
indicates the minimum capacity of the underlying buffer, with the implementation being free to increase it.
- def toReactiveProcessor[I, O](source: ConcurrentSubject[I, O], bufferSize: Int)(implicit s: Scheduler): Processor[I, O]
Transforms the source ConcurrentSubject into a
org.reactivestreams.Processorinstance as defined by the Reactive Streams specification.Transforms the source ConcurrentSubject into a
org.reactivestreams.Processorinstance as defined by the Reactive Streams specification.- bufferSize
a strictly positive number, representing the size of the buffer used and the number of elements requested on each cycle when communicating demand, compliant with the reactive streams specification
This is the API documentation for the Monix library.
Package Overview
monix.execution exposes lower level primitives for dealing with asynchronous execution:
Atomictypes, as alternative tojava.util.concurrent.atomicmonix.catnap exposes pure abstractions built on top of the Cats-Effect type classes:
monix.eval is for dealing with evaluation of results, thus exposing Task and Coeval.
monix.reactive exposes the
Observablepattern:Observableimplementationsmonix.tail exposes Iterant for purely functional pull based streaming:
BatchandBatchCursor, the alternatives to Scala'sIterableandIteratorrespectively that we are using within Iterant's encodingYou can control evaluation with type you choose - be it Task, Coeval, cats.effect.IO or your own as long as you provide correct cats-effect or cats typeclass instance.