AsyncSingleTransform

abstract def onNext(in: In)(implicit ec: ExecutionContext): Future[Out]

Map each successive stream element.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def append[Super >: Out](elems: Iterable[Super]): Transform[_ <: Out, Super]

def appendThese[Super >: Out](elems: Super*): Transform[_ <: Out, Super]

final def apply(in: In)(implicit ec: ExecutionContext): Future[Out]

The core abstract method that must be implemented by each instance, providing the function behavior.

def asAsync: AsyncFunc[In, Out]

Shortcut for a cast to AsyncFunc.

final def asInstanceOf[T0]: T0

def asSync: SyncFunc[In, Out]

Shortcut for a cast to SyncFunc.

def build()(implicit ec: ExecutionContext): RunningStream

Materializes the stream, including all components linked (transitively) to this one, and starts running it.

implicit def builder: FutureStreamBuilder

def clone(): AnyRef

def collect[M[_]]()(implicit cbf: CanBuildFrom[Nothing, Out, M[Out]]): Transform[_ <: Out, M[Out]]

def collectSuper[Super >: Out, M[_]]()(implicit cbf: CanBuildFrom[Nothing, Super, M[Super]]): Transform[Super, M[Super]]

This overload of collect lets you specify an explicit supertype bound of Out (so you cannot upcast past it) and in exchange get a precise non-existential return type.

def combine[Res](next: Sink[Out, Res]): Sink[In, Res]

Irreversibly connects to the sink.

def compose[C](next: Func[Out, C])(implicit ec: ExecutionContext): Func[In, C]

Creates a new function composing these two, which is synchronous iff both inputs were synchronous.

def composeFailure(handler: (Throwable) ⇒ Unit)(implicit ec: ExecutionContext): Func[In, Out]

Returns a new function that passes any exceptions in the original function to handler.

def concat[Elem, Super >: Out]()(implicit ev: <:<[Super, TraversableOnce[Elem]], cbf: CanBuildFrom[Nothing, Elem, Super]): Transform[_ <: Out, Super]

def concatWith[Super >: Out](sources: SourceComponent[Super]*): SourceComponent[Super]

Concatenate these sources after the current one.

def connect(next: SinkComponent[Out]): next.type

Irreversibly join this source with that sink.

def discard(): StreamOutput[_ <: Out, Unit]

def drive[Res](consumer: StreamConsumer[Out, Res]): StreamOutput[_ <: Out, Res]

def drop(count: Long): SourceComponent[Out]

def dropElements[Elem](count: Long)(implicit ev: <:<[Out, Traversable[Elem]], cbf: CanBuildFrom[Nothing, Elem, Out]): Transform[_ <: Out, Out]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(filter: (Out) ⇒ Boolean)(implicit ec: ExecutionContext): SourceComponent[Out]

def filterAsync(filter: (Out) ⇒ Future[Boolean])(implicit ec: ExecutionContext): SourceComponent[Out]

def filterFunc(filter: Func[Out, Boolean])(implicit ec: ExecutionContext): SourceComponent[Out]

def finalize(): Unit

def flatMap[Next](mapper: (Out) ⇒ Iterable[Next], onComplete: ⇒ Iterable[Next]): SourceComponent[Next]

def flatMap[Next](mapper: (Out) ⇒ Iterable[Next]): SourceComponent[Next]

def flatMapAsync[Next](mapper: (Out) ⇒ Future[Iterable[Next]], onComplete: ⇒ Future[Iterable[Next]]): SourceComponent[Next]

def flatMapAsync[Next](mapper: (Out) ⇒ Future[Iterable[Next]]): SourceComponent[Next]

def flatMapFunc[Next](mapper: Func[Out, Iterable[Next]], onComplete: Func[Unit, Iterable[Next]] = Func(emptyIterable)): SourceComponent[Next]

def flatten[Elem]()(implicit ev: <:<[Out, Iterable[Elem]]): SourceComponent[Elem]

def fold[Super >: Out, Res](init: Res)(onNext: (Res, Super) ⇒ Res): SourceComponent[Res]

def foldAsync[Super >: Out, Res](init: Res)(onNext: ((Res, Super)) ⇒ Future[Res]): SourceComponent[Res]

def foldFunc[Super >: Out, Res](init: Res)(onNext: Func[(Res, Super), Res]): SourceComponent[Res]

def foreach[Super >: Out, Res](func: (Super) ⇒ Unit, onComplete: ⇒ Res, onError: (Throwable) ⇒ Unit): StreamOutput[Super, Res]

def foreach[Super >: Out, Res](func: (Super) ⇒ Unit, onComplete: ⇒ Res): StreamOutput[Super, Res]

def foreach[Super >: Out](func: (Super) ⇒ Unit): StreamOutput[Super, Unit]

def foreachAsync[Super >: Out, Res](func: (Super) ⇒ Future[Unit], onComplete: ⇒ Future[Res], onError: (Throwable) ⇒ Unit): StreamOutput[Super, Res]

def foreachAsync[Super >: Out, Res](func: (Super) ⇒ Future[Unit], onComplete: ⇒ Future[Res]): StreamOutput[Super, Res]

def foreachAsync[Super >: Out](func: (Super) ⇒ Future[Unit]): StreamOutput[Super, Unit]

def foreachFunc[Super >: Out, Res](func: Func[Super, Unit], onComplete: Func[Unit, Res] = Func.nop, onError: Func[Throwable, Unit] = Func.nop): StreamOutput[Super, Res]

def foreachTr(func: (Out) ⇒ Unit): Transform[_ <: Out, Out]

def foreachTrAsync(func: (Out) ⇒ Future[Unit]): Transform[_ <: Out, Out]

def foreachTrFunc(func: Func[Out, Unit]): Transform[_ <: Out, Out]

final def getClass(): Class[_]

def hashCode(): Int

def head(): Transform[_ <: Out, Out]

def headOption(): Transform[_ <: Out, Option[Out]]

final def isInstanceOf[T0]: Boolean

def isNop: Boolean

Returns true iff this function is either Func.nop or Func.nopAsync.

def isPass: Boolean

Returns true iff this is a function built by Func.pass.

def isSync: Boolean

Returns true iff this is a SyncFunc

def map[Next](mapper: (Out) ⇒ Next, onComplete: ⇒ Unit): SourceComponent[Next]

def map[Next](mapper: (Out) ⇒ Next): SourceComponent[Next]

def mapAsync[Next](mapper: (Out) ⇒ Future[Next], onComplete: ⇒ Future[Unit]): SourceComponent[Next]

def mapAsync[Next](mapper: (Out) ⇒ Future[Next]): SourceComponent[Next]

def mapFunc[Next](mapper: Func[Out, Next], onComplete: Func[Unit, Unit] = Func.nop): SourceComponent[Next]

def merge[Super >: Out](sources: SourceComponent[Super]*): Merger[Super]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onComplete(): Unit

Called when the component completes.

def onComplete(onComplete: ⇒ Unit): Transform[_ <: Out, Out]

def onCompleteAsync(onComplete: ⇒ Future[Unit]): Transform[_ <: Out, Out]

def onCompleteFunc(onComplete: Func[Unit, Unit]): Transform[_ <: Out, Out]

def onError(throwable: Throwable): Unit

Called on stream failure.

final def onError: Func[Throwable, Unit]

def onError(onError: (Throwable) ⇒ Unit): Transform[_ <: Out, Out]

def onErrorAsync(onError: (Throwable) ⇒ Future[Unit]): Transform[_ <: Out, Out]

def onErrorFunc(onError: Func[Throwable, Unit]): Transform[_ <: Out, Out]

def pipe[Next](next: Transform[Out, Next]): Pipe[In, Next]

Irreversibly connects to the next transform

def pipe[Next](pipe: Pipe[Out, Next]): Pipe[In, Next]

Irreversibly connects to the pipe's input Source.

def prepend[Super >: Out](elems: Iterable[Super]): Transform[_ <: Out, Super]

def prependThese[Super >: Out](elems: Super*): Transform[_ <: Out, Super]

def recover[U >: Out](handler: PartialFunction[Throwable, U])(implicit ec: ExecutionContext): Func[In, U]

Adds a synchronous recovery stage to this function, which handles both synchronously thrown exceptions, and failing futures returned by asynchronous functions.

def recoverWith[U >: Out](handler: PartialFunction[Throwable, Future[U]])(implicit ec: ExecutionContext): AsyncFunc[In, U]

Adds an asynchronous recovery stage to this function, which handles both synchronously thrown exceptions, and failing futures returned by asynchronous functions.

def roundRobin(outputCount: Int): Splitter[_ <: Out]

def scatter(outputCount: Int): Scatterer[_ <: Out]

def single(): StreamOutput[_, Out]

def singleResult()(implicit ec: ExecutionContext): Future[Out]

def someApply(a: In)(implicit ec: ExecutionContext): Future[Out]

Returns either B or a Future[B] depending on the type of this Func.

def someRecover[U >: Out](handler: Func[Throwable, U])(implicit ec: ExecutionContext): Func[In, U]

Adds a recovery stage to this function, which handles both synchronously thrown exceptions, and failing futures returned by asynchronous functions.

def sourceComponent: SourceComponent[Out]

def split(outputCount: Int, outputChooser: (Out) ⇒ BitSet): Splitter[_ <: Out]

def splitAsync(outputCount: Int, outputChooser: (Out) ⇒ Future[BitSet]): Splitter[_ <: Out]

def splitFunc(outputCount: Int, outputChooser: Func[Out, BitSet]): Splitter[_ <: Out]

def suppressErrors()(implicit ec: ExecutionContext): Func[In, Unit]

Suppress all errors matched by the NonFatal extractor.

final def synchronized[T0](arg0: ⇒ T0): T0

def take(count: Long): SourceComponent[Out]

def takeElements[Elem](count: Long)(implicit ev: <:<[Out, Traversable[Elem]], cbf: CanBuildFrom[Nothing, Elem, Out]): Transform[_ <: Out, Out]

def tapHead(): Transform[_ <: Out, Out] with Aside[Option[Out]]

def tee(outputCount: Int): Splitter[_ <: Out]

def to[Res](sink: Sink[Out, Res]): sink.type

Irreversibly join this source with that sink.

def to[Next](pipe: Pipe[Out, Next]): pipe.type

Irreversibly join this source with that pipe's sink.

def to(sink: SinkComponent[Out]): sink.type

Irreversibly join this source with that sink.

def toIndexedSeq(): Transform[_ <: Out, IndexedSeq[Out]]

def toList(): Transform[_ <: Out, List[Out]]

def toSeq(): Transform[_ <: Out, Seq[Out]]

def toSet[Super >: Out](): Transform[_ <: Out, Set[Super]]

def toString(): String

def toVector(): Transform[_ <: Out, Vector[Out]]

def transform[Next](tr: Transform[Out, Next]): tr.type

Irreversibly join this source with that transform.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def ~>[C](next: Func[Out, C])(implicit ec: ExecutionContext): Func[In, C]

Alias for compose.