abstract class StreamOps[A] extends AnyRef

Defines all the transformations that are available on Spout, Pipe and fan-out sub-streams.

Self Type
StreamOps[A]
Linear Supertypes
AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. StreamOps
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. final class BranchOut [AA <: HList, L <: HList, S] extends FanIn[L, S]

    Closed fan-out, where the number of fan-out sub streams and their (potentially differing) types are predefined.

    Closed fan-out, where the number of fan-out sub streams and their (potentially differing) types are predefined.

    AA

    element types of the still unconsumed fan-out sub-streams as an HList

    L

    element types of all unterminated fan-in sub-streams as an HList

    S

    super-type of all unterminated fan-in sub-streams

  2. sealed class FanIn [L <: HList, S] extends AnyRef

    Heterogeneous fan-in, where the fan-in streams have potentially differing types.

    Heterogeneous fan-in, where the fan-in streams have potentially differing types.

    L

    element types of all unterminated fan-in sub-streams as an HList

    S

    super-type of all unterminated fan-in sub-streams

  3. final class FanIn0 [S] extends AnyRef

    Homogeneous fan-in, where all fan-in streams have the same type.

    Homogeneous fan-in, where all fan-in streams have the same type.

    S

    super-type of all fan-in sub-streams

  4. final class FanOut [L <: HList, S] extends FanIn[L, S]

    Open fan-out, where all fan-out sub streams have the same type and there can be arbitrarily many of them.

    Open fan-out, where all fan-out sub streams have the same type and there can be arbitrarily many of them.

    L

    element types of all unterminated fan-in sub-streams as an HList

    S

    super-type of all unterminated fan-in sub-streams

  5. abstract type Repr[T] <: StreamOps[T] { type Repr[X] <: StreamOps.this.Repr[X] }

Abstract Value Members

  1. abstract def append[T](stage: StageImpl): Repr[T]
    Attributes
    protected
  2. abstract def base: Inport
    Attributes
    protected
  3. abstract def via[B](pipe: Pipe[A, B]): Repr[B]
  4. abstract def wrap[T](inport: Inport): Repr[T]
    Attributes
    protected

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ++[B >: A](other: Spout[B]): Repr[B]
  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. final def async(dispatcherId: String = ""): Repr[A]
  7. final def asyncBoundary(dispatcherId: String = "", bufferSize: Int = 32): Repr[A]
  8. final def attach[L <: HList, S, SS](fanIn: Spout.FanIn[L, S] forSome {type _$4})(implicit ev: Lub[A, S, SS]): FanIn[::[A, L], SS]
  9. final def attach[L <: HList, S](branchOut: Spout.BranchOut[L, _$2, _$3] forSome {type _$1, type _$2, type _$3})(implicit u: Aux[::[A, L], S]): FanIn[::[A, L], S]
  10. final def attach[T, S, O](sub: Spout[T])(implicit ev: Lub[A, T, O]): FanIn[::[A, ::[T, HNil]], O]
  11. final def attachAll[SS, S >: A](subs: Traversable[SS])(implicit ev: Aux[SS, S]): FanIn0[S]
  12. final def attachLeft[T, S, O](sub: Spout[T])(implicit ev: Lub[A, T, O]): FanIn[::[T, ::[A, HNil]], O]
  13. final def attachN[T, O](n: Nat, fo: Spout.FanOut[_, _])(implicit f: Fill[N, T], ti: ToInt[N], lub: Lub[A, T, O]): FanIn[::[A, Out], O]
  14. final def buffer(size: Int, requestStrategy: RequestStrategy = ...): Repr[A]
  15. final def bufferDropping(size: Int, overflowStrategy: OverflowStrategy): Repr[A]
  16. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  17. final def collect[B](pf: PartialFunction[A, B]): Repr[B]
  18. final def concat[B >: A](other: Spout[B]): Repr[B]
  19. final def conflate[B >: A](aggregate: (B, A) ⇒ B): Repr[B]
  20. final def conflateToLast[B >: A]: Repr[B]
  21. final def conflateWithSeed[B](lift: (A) ⇒ B)(aggregate: (B, A) ⇒ B): Repr[B]
  22. final def deduplicate: Repr[A]
  23. final def delay(f: (A) ⇒ FiniteDuration): Repr[A]
  24. final def drop(n: Long): Repr[A]
  25. final def dropAll: Repr[A]
  26. final def dropLast(n: Int): Repr[A]
  27. final def dropWhile(predicate: (A) ⇒ Boolean): Repr[A]
  28. final def dropWithin(d: FiniteDuration): Repr[A]
  29. final def duplicate: Repr[A]
  30. final def elementAt(index: Long): Repr[A]
  31. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  32. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  33. final def expand[B](zero: Iterator[B], extrapolate: (A) ⇒ Iterator[B]): Repr[B]

    Rate-detaches the downstream from the upstream by allowing the downstream to consume elements faster than the upstream produces them.

    Rate-detaches the downstream from the upstream by allowing the downstream to consume elements faster than the upstream produces them. Each element coming in from upstream is passed through the given extrapolate function. The produced iterator is then pulled from at least once (if non-empty). Afterwards, if the downstream is ready to consume more elements but the upstream hasn't delivered any yet the iterator will be drained until it has no more elements or the next element from upstream arrives.

    If the upstream produces elements at a faster rate than the downstream can consume them each iterator produced by the extrapolate function will only ever have its first element pulled and the upstream will be backpressured, i.e. the downstream will slow down the upstream.

    zero

    iterator used for supplying elements to downstream before the first element arrives from upstream, only pulled from if the first demand from downstream arrives before the first element from upstream.

    extrapolate

    function producing the elements that each element from upstream is expanded to

  34. final def expand[B](extrapolate: (A) ⇒ Iterator[B]): Repr[B]
  35. final def expand(): Repr[A]
  36. final def fanOutBroadcast(bufferSize: Int = 0, requestStrategy: RequestStrategy = ..., eagerCancel: Boolean = false): FanOut[HNil, Nothing]
  37. final def fanOutRoundRobin(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  38. final def fanOutSequential(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  39. final def fanOutSwitch[N <: Nat](f: (A) ⇒ Int, eagerCancel: Boolean)(implicit ti: ToInt[N], fl: Fill[N, A]): BranchOut[Out, HNil, Nothing]
  40. final def fanOutSwitch[N <: Nat](f: (A) ⇒ Int)(implicit ti: ToInt[N], fl: Fill[N, A]): BranchOut[Out, HNil, Nothing]
  41. final def fanOutSwitch(n: Nat, eagerCancel: Boolean = false)(f: (A) ⇒ Int)(implicit ti: ToInt[N], fl: Fill[N, A]): BranchOut[Out, HNil, Nothing]
  42. final def fanOutToAny(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  43. final def fanOutUnZip[L <: HList](eagerCancel: Boolean = false)(implicit ev: FromProduct[A, L]): BranchOut[L, HNil, Nothing]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  44. final def filter[T](implicit classTag: ClassTag[T]): Repr[T]
  45. final def filter(predicate: (A) ⇒ Boolean): Repr[A]
  46. final def filterNot(predicate: (A) ⇒ Boolean): Repr[A]
  47. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  48. final def first: Repr[A]
  49. final def flatMap[B, C](f: (A) ⇒ B, parallelism: Int = 1)(implicit ev: Aux[B, C]): Repr[C]
  50. final def flattenConcat[B](parallelism: Int = 1)(implicit ev: Aux[A, B]): Repr[B]
  51. final def flattenMerge[B](parallelism: Int)(implicit ev: Aux[A, B]): Repr[B]
  52. final def flattenRoundRobin[B](parallelism: Int)(implicit ev: Aux[A, B]): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  53. final def flattenSorted[B](parallelism: Int)(implicit arg0: Ordering[B], ev: Aux[A, B]): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  54. final def flattenToSeq[B](parallelism: Int)(implicit ev: Aux[A, B]): Repr[Seq[B]]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  55. final def fold[B](zero: B)(f: (B, A) ⇒ B): Repr[B]
  56. final def foldAsync[B](zero: B)(f: (B, A) ⇒ Future[B]): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  57. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  58. final def groupBy[K](maxSubstreams: Int, reopenCancelledSubs: Boolean = false, eagerComplete: Boolean = false)(f: (A) ⇒ K): Repr[Spout[A]]

    maxSubstreams

    the maximum number of sub-streams allowed. Exceeding this limit causes to stream to be completed with an IllegalStateException.

    reopenCancelledSubs

    if true cancellation of a sub-stream will trigger a new sub-stream for the respective key to be emitted to the downstream (whenever a respective element arrives), if false all elements that are keyed to a cancelled sub-stream will simply be dropped

    eagerComplete

    if true the cancellation of the (main) downstream will immediately be propagated to upstream and all sub-stream will be completed, if false the cancellation of the (main) downstream will keep the stream running, but cause all elements keyed to not yet open sub-streams to be dropped.

    f

    the key function. Must not return null for any element. Otherwise the stream is completed with a RuntimeException.

  59. final def grouped(groupSize: Int, emitSingleEmpty: Boolean = false): Repr[Seq[A]]
  60. final def groupedTo[M[+_]](groupSize: Int, emitSingleEmpty: Boolean = false)(implicit cbf: CanBuildFrom[M[A], A, M[A]]): Repr[M[A]]
  61. final def groupedWithin(maxSize: Int, duration: FiniteDuration): Repr[Vector[A]]

    Groups incoming elements received within the given duration into Vector instances that have at least one and at most maxSize elements.

    Groups incoming elements received within the given duration into Vector instances that have at least one and at most maxSize elements. A group is emitted when maxSize has been reached or the duration since the last emit has expired. If no elements are received within the duration then nothing is emitted at time expiration, but the next incoming element will be emitted immediately after reception as part of a single-element group.

    maxSize

    the maximum size of the emitted Vector instances, must be > 0

    duration

    the time period over which to aggregate, must be > 0

  62. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  63. final def headAndTail: Repr[(A, Spout[A])]
  64. def identity: Repr[A]

    The underlying representation without additional stage appended.

  65. final def injectBroadcast(parallelism: Int): Repr[Spout[A]]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  66. final def injectRoundRobin(parallelism: Int): Repr[Spout[A]]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  67. final def injectSequential(bufferSize: Int = 1): Repr[Spout[A]]
  68. final def injectToAny(parallelism: Int): Repr[Spout[A]]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  69. final def interleave[B >: A](other: Spout[B], segmentSize: Int = 1, eagerComplete: Boolean = false): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  70. final def intersperse[B >: A](start: B, inject: B, end: B): Repr[B]
  71. final def intersperse[B >: A](inject: B): Repr[B]
  72. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  73. final def last: Repr[A]
  74. final def logSignal(marker: String, log: (String, StreamEvent[A]) ⇒ Unit = defaultLogSignal): Repr[A]
  75. final def map[B](f: (A) ⇒ B): Repr[B]
  76. final def mapAsync[B](parallelism: Int)(f: (A) ⇒ Future[B]): Repr[B]
  77. final def mapAsyncUnordered[B](parallelism: Int)(f: (A) ⇒ Future[B]): Repr[B]
  78. final def merge[B >: A](other: Spout[B], eagerComplete: Boolean = false): Repr[B]
  79. final def mergeSorted[B >: A](other: Spout[B], eagerComplete: Boolean = false)(implicit arg0: Ordering[B]): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  80. final def mergeToEither[B](right: Spout[B]): Repr[Either[A, B]]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  81. final def multiply(factor: Int): Repr[A]
  82. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  83. final def nop: Repr[A]
  84. final def notify(): Unit
    Definition Classes
    AnyRef
  85. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  86. final def onCancel(callback: ⇒ Unit): Repr[A]
  87. final def onComplete(callback: ⇒ Unit): Repr[A]
  88. final def onElement(callback: (A) ⇒ Unit): Repr[A]
  89. final def onError(callback: (Throwable) ⇒ Unit): Repr[A]
  90. final def onRequest(callback: (Int) ⇒ Unit): Repr[A]
  91. final def onSignal(callback: (StreamEvent[A]) ⇒ Unit): Repr[A]
  92. final def onSignalPF(callback: PartialFunction[StreamEvent[A], Unit]): Repr[A]
  93. final def onStart(callback: () ⇒ Unit): Repr[A]
  94. final def onTerminate(callback: (Option[Throwable]) ⇒ Unit): Repr[A]
  95. final def orElse[B >: A](other: Spout[B]): Repr[B]
  96. final def prefixAndTail(n: Int): Repr[(Seq[A], Spout[A])]
  97. final def prefixAndTailTo[S[+_]](n: Int)(implicit cbf: CanBuildFrom[S[A], A, S[A]]): Repr[(S[A], Spout[A])]
  98. final def protect[B](recreate: (Option[Throwable]) ⇒ Pipe[A, B]): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  99. final def recover[B >: A](pf: PartialFunction[Throwable, B]): Repr[B]
  100. final def recoverToTry: Repr[Try[A]]
  101. final def recoverWith[B >: A](maxRecoveries: Long)(pf: PartialFunction[Throwable, Spout[B]]): Repr[B]
  102. final def reduce[B >: A](f: (B, B) ⇒ B): Repr[B]
  103. final def sample(d: FiniteDuration): Repr[A]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  104. final def scan[B](zero: B)(f: (B, A) ⇒ B): Repr[B]
  105. final def scanAsync[B](zero: B)(f: (B, A) ⇒ Future[B]): Repr[B]
    Annotations
    @compileTimeOnly( "Not yet implemented" )
  106. final def slice(startIndex: Long, length: Long): Repr[A]
  107. final def sliceEvery(dropLen: Long, takeLen: Long): Repr[A]
  108. final def sliding(windowSize: Int): Repr[Seq[A]]
  109. final def slidingTo[M[+_]](windowSize: Int)(implicit cbf: CanBuildFrom[M[A], A, M[A]], ev: <:<[M[A], Seq[A]]): Repr[M[A]]
  110. final def split(f: (A) ⇒ Command, eagerCancel: Boolean = true): Repr[Spout[A]]
  111. final def splitAfter(f: (A) ⇒ Boolean, eagerCancel: Boolean = true): Repr[Spout[A]]
  112. final def splitWhen(f: (A) ⇒ Boolean, eagerCancel: Boolean = true): Repr[Spout[A]]
  113. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  114. final def take(count: Long): Repr[A]
  115. final def takeEveryNth(n: Long): Repr[A]
  116. final def takeLast(n: Int): Repr[A]
  117. final def takeWhile(predicate: (A) ⇒ Boolean): Repr[A]
  118. final def takeWithin(d: FiniteDuration): Repr[A]
  119. final def tee(drain: Drain[A, Unit], eagerCancel: Boolean = false): Repr[A]
  120. final def throttle(cost: Int, per: FiniteDuration, burst: Int, costFn: (A) ⇒ Int): Repr[A]
  121. final def throttle(elements: Int, per: FiniteDuration, burst: Int = 1): Repr[A]
  122. def toString(): String
    Definition Classes
    AnyRef → Any
  123. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  124. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  125. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  126. final def withCompletionTimeout(timeout: FiniteDuration): Repr[A]
  127. final def withIdleTimeout(timeout: FiniteDuration): Repr[A]
  128. final def withInitialTimeout(timeout: FiniteDuration): Repr[A]
  129. final def withLimit(maxElements: Long): Repr[A]
  130. final def withLimitWeighted(max: Long, cost: (A) ⇒ Long): Repr[A]
  131. final def zip[B](other: Spout[B]): Repr[(A, B)]

Inherited from AnyRef

Inherited from Any

Ungrouped