Packages

object ConcurrentSubject extends Serializable

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ConcurrentSubject
  2. Serializable
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def apply[A](multicast: MulticastStrategy[A], overflow: Synchronous[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
  5. def apply[A](multicast: MulticastStrategy[A])(implicit s: Scheduler): ConcurrentSubject[A, A]
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def async[A](implicit s: Scheduler): ConcurrentSubject[A, A]

    Subject recipe for building async subjects.

  8. 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.

  9. 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

  10. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  11. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  12. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  13. 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.

  14. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  15. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  16. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  17. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  19. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  20. 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.

  21. def publish[A](implicit s: Scheduler): ConcurrentSubject[A, A]

    Subject recipe for building publish subjects.

  22. 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.

  23. def publishToOne[A](implicit s: Scheduler): ConcurrentSubject[A, A]

    Subject recipe for building PublishToOneSubject.

  24. 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.

  25. 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.

  26. 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.

  27. def replay[A](implicit s: Scheduler): ConcurrentSubject[A, A]

    Subject recipe for building replay subjects.

  28. 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.

  29. 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.

  30. 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.

  31. 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.

  32. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  33. 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

  34. def toString(): String
    Definition Classes
    AnyRef → Any
  35. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  36. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  37. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped