monix.reactive.MulticastStrategy.scala Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2014-2016 by its authors. Some rights reserved.
 * See the project homepage at: https://monix.io
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package monix.reactive

/** The `MulticastStrategy` specifies the strategy for
  * building data-sources that are shared between multiple subscribers.
  *
  * By default observables tend to be cold.
  */
sealed abstract class MulticastStrategy[+A] extends Serializable

/** The [[MulticastStrategy]] enumerated.
  *
  * @define publish The `Publish` strategy is for emitting to a subscriber
  *         only those items that are emitted by the source subsequent
  *         to the time of the subscription.
  *
  *         Corresponds to [[Pipe.publish]].
  *
  * @define behavior The `Behavior` strategy is for building multicast observables that
  *         emit the most recently emitted item by the source before the
  *         source starts being mirrored.
  *
  *         Corresponds to [[Pipe.behavior]].
  *
  * @define async The `Async` strategy is for building multicast observables that
  *         emit the last value (and only the last value) of the source
  *         and only after the source completes.
  *
  *         Corresponds to [[Pipe.async]].
  *
  * @define replay The `Replay` strategy is for building multicast observables
  *         that repeat all the generated items by the source, regardless of
  *         when the source is subscribed.
  *
  *         Corresponds to [[Pipe.replay[A](initial:Seq[A]* Pipe.replay]].
  *
  * @define replayLimited   The `ReplayLimited` strategy is for building multicast
  *         observables that repeat the generated items by the source, but limited by the
  *         maximum size of the underlying buffer.
  *
  *         When maximum size is reached, the underlying buffer starts dropping
  *         older events. Note that the size of the resulting buffer is not necessarily
  *         the given capacity, as the implementation may choose to increase it for optimisation
  *         purposes.
  *
  *         Corresponds to [[Pipe.replayLimited[A](capacity:Int,initial* Pipe.replayLimited]].
  */
object MulticastStrategy {
  /** $publish */
  def publish[A]: MulticastStrategy[A] = Publish

  /** $publish */
  case object Publish extends MulticastStrategy[Nothing]

  /** $behavior */
  def behavior[A](initial: A): MulticastStrategy[A] = Behavior(initial)

  /** $behavior */
  case class Behavior[A](initial: A) extends MulticastStrategy[A]

  /** $async */
  def async[A]: MulticastStrategy[A] = Async

  /** $async */
  case object Async extends MulticastStrategy[Nothing]

  /** $replay */
  def replay[A]: MulticastStrategy[A] = Replay(Seq.empty)

  /** $replay */
  def replay[A](initial: Seq[A]): MulticastStrategy[A] = Replay(initial)

  /** $replay */
  case class Replay[A](initial: Seq[A]) extends MulticastStrategy[A]

  /** $replayLimited */
  def replayLimited[A](capacity: Int): MulticastStrategy[A] =
    ReplayLimited(capacity, Seq.empty)

  /** $replayLimited */
  def replayLimited[A](capacity: Int, initial: Seq[A]): MulticastStrategy[A] =
    ReplayLimited(capacity, initial)

  /** $replayLimited */
  case class ReplayLimited[A](capacity: Int, initial: Seq[A])
    extends MulticastStrategy[A]
}