final
class
SubStreamOps[A, L <: HList, S, F <: FanIn[_$8, _$9] forSome {type _$7, type _$8, type _$9}] extends StreamOps[A]
Type Members
-
final
class
BranchOut[AA <: HList, L <: HList, S] extends FanIn[L, S]
-
sealed
class
FanIn[L <: HList, S] extends AnyRef
-
final
class
FanIn0[S] extends AnyRef
-
final
class
FanOut[L <: HList, S] extends FanIn[L, S]
-
type
Repr[T] = SubStreamOps[T, L, S, F]
Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
++[B >: A](other: Spout[B]): Repr[B]
-
final
def
==(arg0: Any): Boolean
-
def
append[T](stage: StageImpl): Repr[T]
-
final
def
asInstanceOf[T0]: T0
-
final
def
async(dispatcherId: String = ""): Repr[A]
-
final
def
asyncBoundary(dispatcherId: String = "", bufferSize: Int = 16): Repr[A]
-
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]
-
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]
-
final
def
attach[T, S, O](sub: Spout[T])(implicit ev: Lub[A, T, O]): FanIn[::[A, ::[T, HNil]], O]
-
final
def
attachAll[SS, S >: A](subs: Traversable[SS])(implicit ev: Aux[SS, S]): FanIn0[S]
-
final
def
attachLeft[T, S, O](sub: Spout[T])(implicit ev: Lub[A, T, O]): FanIn[::[T, ::[A, HNil]], O]
-
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]
-
def
base: Inport
-
final
def
buffer(size: Int, requestStrategy: RequestStrategy = ...): Repr[A]
-
final
def
bufferDropping(size: Int, overflowStrategy: OverflowStrategy): Repr[A]
-
def
clone(): AnyRef
-
final
def
collect[B](pf: PartialFunction[A, B]): Repr[B]
-
final
def
concat[B >: A](other: Spout[B]): Repr[B]
-
final
def
conflate[B >: A](aggregate: (B, A) ⇒ B): Repr[B]
-
final
def
conflateToLast[B >: A]: Repr[B]
-
final
def
conflateWithSeed[B](lift: (A) ⇒ B)(aggregate: (B, A) ⇒ B): Repr[B]
-
final
def
deduplicate: Repr[A]
-
final
def
delay(f: (A) ⇒ FiniteDuration): Repr[A]
-
final
def
drop(n: Long): Repr[A]
-
final
def
dropAll: Repr[A]
-
final
def
dropLast(n: Int): Repr[A]
-
final
def
dropWhile(predicate: (A) ⇒ Boolean): Repr[A]
-
final
def
dropWithin(d: FiniteDuration): Repr[A]
-
final
def
duplicate: Repr[A]
-
final
def
elementAt(index: Long): Repr[A]
-
def
end[SS, P <: HList](implicit ev0: Lub[S, A, SS], ev: shapeless.ops.hlist.Prepend.Aux[L, ::[A, HNil], P]): F.FI[P, SS]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
final
def
expand[B](zero: Iterator[B], extrapolate: (A) ⇒ Iterator[B]): Repr[B]
-
final
def
expand[B](extrapolate: (A) ⇒ Iterator[B]): Repr[B]
-
final
def
expand(): Repr[A]
-
final
def
fanOutBroadcast(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
-
final
def
fanOutBroadcastBuffered(bufferSize: Int, requestStrategy: RequestStrategy = ..., eagerCancel: Boolean = false): FanOut[HNil, Nothing]
-
final
def
fanOutRoundRobin(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
-
final
def
fanOutSequential(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
-
final
def
fanOutSwitch[N <: Nat](f: (A) ⇒ Int, eagerCancel: Boolean)(implicit ti: ToInt[N], fl: Fill[N, A]): BranchOut[Out, HNil, Nothing]
-
final
def
fanOutSwitch[N <: Nat](f: (A) ⇒ Int)(implicit ti: ToInt[N], fl: Fill[N, A]): BranchOut[Out, HNil, Nothing]
-
final
def
fanOutSwitch(n: Nat, eagerCancel: Boolean = false)(f: (A) ⇒ Int)(implicit ti: ToInt[N], fl: Fill[N, A]): BranchOut[Out, HNil, Nothing]
-
final
def
fanOutToAny(eagerCancel: Boolean = false): FanOut[HNil, Nothing]
-
final
def
fanOutUnZip[L <: HList](eagerCancel: Boolean = false)(implicit ev: FromProduct[A, L]): BranchOut[L, HNil, Nothing]
-
final
def
filter[T](implicit classTag: ClassTag[T]): Repr[T]
-
final
def
filter(predicate: (A) ⇒ Boolean): Repr[A]
-
final
def
filterNot(predicate: (A) ⇒ Boolean): Repr[A]
-
def
finalize(): Unit
-
final
def
first: Repr[A]
-
final
def
flatMap[B, C](f: (A) ⇒ B, parallelism: Int = 1)(implicit ev: Aux[B, C]): Repr[C]
-
final
def
flattenConcat[B](parallelism: Int = 1)(implicit ev: Aux[A, B]): Repr[B]
-
final
def
flattenMerge[B](parallelism: Int)(implicit ev: Aux[A, B]): Repr[B]
-
final
def
flattenRoundRobin[B](parallelism: Int)(implicit ev: Aux[A, B]): Repr[B]
-
final
def
flattenSorted[B](parallelism: Int)(implicit arg0: Ordering[B], ev: Aux[A, B]): Repr[B]
-
final
def
flattenToSeq[B](parallelism: Int)(implicit ev: Aux[A, B]): Repr[Seq[B]]
-
final
def
fold[B](zero: B)(f: (B, A) ⇒ B): Repr[B]
-
final
def
foldAsync[B](zero: B)(f: (B, A) ⇒ Future[B]): Repr[B]
-
final
def
getClass(): Class[_]
-
final
def
groupBy[K](maxSubstreams: Int, reopenCancelledSubs: Boolean = false, eagerComplete: Boolean = false)(f: (A) ⇒ K): Repr[Spout[A]]
-
final
def
grouped(groupSize: Int, emitSingleEmpty: Boolean = false): Repr[Seq[A]]
-
final
def
groupedTo[M[+_]](groupSize: Int, emitSingleEmpty: Boolean = false)(implicit cbf: CanBuildFrom[M[A], A, M[A]]): Repr[M[A]]
-
final
def
groupedWithin(maxSize: Int, duration: FiniteDuration): Repr[Vector[A]]
-
def
hashCode(): Int
-
final
def
headAndTail: Repr[(A, Spout[A])]
-
def
identity: Repr[A]
-
final
def
injectBroadcast(parallelism: Int): Repr[Spout[A]]
-
final
def
injectRoundRobin(parallelism: Int): Repr[Spout[A]]
-
final
def
injectSequential: Repr[Spout[A]]
-
final
def
injectToAny(parallelism: Int): Repr[Spout[A]]
-
final
def
interleave[B >: A](other: Spout[B], segmentSize: Int = 1, eagerComplete: Boolean = false): Repr[B]
-
final
def
intersperse[B >: A](start: B, inject: B, end: B): Repr[B]
-
final
def
intersperse[B >: A](inject: B): Repr[B]
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
last: Repr[A]
-
final
def
logEvent(marker: String, log: (String, StreamEvent[A]) ⇒ Unit = defaultLogEvent): Repr[A]
-
final
def
map[B](f: (A) ⇒ B): Repr[B]
-
final
def
mapAsync[B](parallelism: Int)(f: (A) ⇒ Future[B]): Repr[B]
-
final
def
mapAsyncUnordered[B](parallelism: Int)(f: (A) ⇒ Future[B]): Repr[B]
-
final
def
merge[B >: A](other: Spout[B], eagerComplete: Boolean = false): Repr[B]
-
final
def
mergeSorted[B >: A](other: Spout[B], eagerComplete: Boolean = false)(implicit arg0: Ordering[B]): Repr[B]
-
final
def
mergeToEither[B](right: Spout[B]): Repr[Either[A, B]]
-
final
def
multiply(factor: Int): Repr[A]
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
nop: Repr[A]
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
onCancel(callback: ⇒ Unit): Repr[A]
-
final
def
onComplete(callback: ⇒ Unit): Repr[A]
-
final
def
onElement(callback: (A) ⇒ Unit): Repr[A]
-
final
def
onError(callback: (Throwable) ⇒ Unit): Repr[A]
-
final
def
onRequest(callback: (Int) ⇒ Unit): Repr[A]
-
final
def
onSignal(callback: (StreamEvent[A]) ⇒ Unit): Repr[A]
-
final
def
onSignalPF(callback: PartialFunction[StreamEvent[A], Unit]): Repr[A]
-
final
def
onStart(callback: () ⇒ Unit): Repr[A]
-
final
def
onTerminate(callback: (Option[Throwable]) ⇒ Unit): Repr[A]
-
final
def
orElse[B >: A](other: Spout[B]): Repr[B]
-
final
def
prefixAndTail(n: Int): Repr[(Seq[A], Spout[A])]
-
final
def
prefixAndTailTo[S[+_]](n: Int)(implicit cbf: CanBuildFrom[S[A], A, S[A]]): Repr[(S[A], Spout[A])]
-
final
def
protect[B](recreate: (Option[Throwable]) ⇒ Pipe[A, B]): Repr[B]
-
final
def
recover[B >: A](pf: PartialFunction[Throwable, B]): Repr[B]
-
final
def
recoverToTry: Repr[Try[A]]
-
final
def
recoverWith[B >: A](maxRecoveries: Long)(pf: PartialFunction[Throwable, Spout[B]]): Repr[B]
-
final
def
reduce[B >: A](f: (B, B) ⇒ B): Repr[B]
-
final
def
sample(d: FiniteDuration): Repr[A]
-
final
def
scan[B](zero: B)(f: (B, A) ⇒ B): Repr[B]
-
final
def
scanAsync[B](zero: B)(f: (B, A) ⇒ Future[B]): Repr[B]
-
final
def
slice(startIndex: Long, length: Long): Repr[A]
-
final
def
sliceEvery(dropLen: Long, takeLen: Long): Repr[A]
-
final
def
sliding(windowSize: Int): Repr[Seq[A]]
-
final
def
slidingTo[M[+_]](windowSize: Int)(implicit cbf: CanBuildFrom[M[A], A, M[A]], ev: <:<[M[A], Seq[A]]): Repr[M[A]]
-
final
def
split(f: (A) ⇒ Command, eagerCancel: Boolean = true): Repr[Spout[A]]
-
final
def
splitAfter(f: (A) ⇒ Boolean, eagerCancel: Boolean = true): Repr[Spout[A]]
-
final
def
splitWhen(f: (A) ⇒ Boolean, eagerCancel: Boolean = true): Repr[Spout[A]]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
final
def
take(count: Long): Repr[A]
-
final
def
takeEveryNth(n: Long): Repr[A]
-
final
def
takeLast(n: Int): Repr[A]
-
final
def
takeWhile(predicate: (A) ⇒ Boolean): Repr[A]
-
final
def
takeWithin(d: FiniteDuration): Repr[A]
-
final
def
tee(drain: Drain[A, Unit], eagerCancel: Boolean = false): Repr[A]
-
final
def
throttle(cost: Int, per: FiniteDuration, burst: Int, costFn: (A) ⇒ Int): Repr[A]
-
final
def
throttle(elements: Int, per: FiniteDuration, burst: Int = 1): Repr[A]
-
def
to(drain: Drain[A, Unit]): F.FI[L, S]
-
def
toString(): String
-
def
via[P <: HList, R, Out](joined: Joined[::[A, HNil], P, R])(implicit vr: ViaResult[P, F, Repr, Out]): Out
-
def
via[B](pipe: Pipe[A, B]): Repr[B]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
final
def
withCompletionTimeout(timeout: FiniteDuration): Repr[A]
-
final
def
withIdleTimeout(timeout: FiniteDuration): Repr[A]
-
final
def
withInitialTimeout(timeout: FiniteDuration): Repr[A]
-
final
def
withLimit(maxElements: Long): Repr[A]
-
final
def
withLimitWeighted(max: Long, cost: (A) ⇒ Long): Repr[A]
-
def
wrap[T](inport: Inport): Repr[T]
-
final
def
zip[B](other: Spout[B]): Repr[(A, B)]
Inherited from AnyRef
Inherited from Any
The operations underneath a fan/branch-out sub.