object ConcurrentSubject extends Serializable
- Source
- ConcurrentSubject.scala
- Alphabetic
- By Inheritance
- ConcurrentSubject
- Serializable
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- 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]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
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
onNext
happens- 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
onNext
happens
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
from[I, O](p: Subject[I, O], overflowStrategy: Synchronous[I])(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.
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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
capacity
given 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
capacity
given 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
capacity
given 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
capacity
given 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.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toReactiveProcessor[I, O](source: ConcurrentSubject[I, O], bufferSize: Int)(implicit s: Scheduler): Processor[I, O]
Transforms the source ConcurrentSubject into a
org.reactivestreams.Processor
instance as defined by the Reactive Streams specification.Transforms the source ConcurrentSubject into a
org.reactivestreams.Processor
instance 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
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
This is the API documentation for the Monix library.
Package Overview
monix.execution exposes lower level primitives for dealing with asynchronous execution:
Atomic
types, as alternative tojava.util.concurrent.atomic
monix.eval is for dealing with evaluation of results, thus exposing Task and Coeval.
monix.reactive exposes the
Observable
pattern:Observable
implementationsmonix.types implements type-class shims, to be translated to type-classes provided by libraries such as Cats or Scalaz.
monix.cats is the optional integration with the Cats library, providing translations for the types described in
monix.types
.monix.scalaz is the optional integration with the Scalaz library, providing translations for the types described in
monix.types
.