core
API
Generated with
core/ox/ox.channels/SourceOps

SourceOps

ox.channels.SourceOps
trait SourceOps[+T]

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Source[T]
trait Channel[T]
class BufferedChannel[T]
class DirectChannel[T]
class CollectSource[T, U]
Self type
Source[T]

Members list

Value members

Concrete methods

def collectAsView[U](f: PartialFunction[T, U]): Source[U]
def concat[U >: T](other: Source[U])(using Ox, StageCapacity): Source[U]
def drain(): Unit
def filter(f: T => Boolean)(using Ox, StageCapacity): Source[T]
def filterAsView(f: T => Boolean): Source[T]
def foreach(f: T => Unit): Unit
def map[U](f: T => U)(using Ox, StageCapacity): Source[U]
def mapAsView[U](f: T => U): Source[U]
def mapPar[U](parallelism: Int)(f: T => U)(using Ox, StageCapacity): Source[U]

Applies the given mapping function f to each element received from this source, and sends the results to the returned channel. At most parallelism invocations of f are run in parallel.

Applies the given mapping function f to each element received from this source, and sends the results to the returned channel. At most parallelism invocations of f are run in parallel.

The mapped results are sent to the returned channel in the same order, in which inputs are received from this source. In other words, ordering is preserved.

Errors from this channel are propagated to the returned channel. Any exceptions that occur when invoking f are propagated as errors to the returned channel as well, and result in interrupting any mappings that are in progress.

Must be run within a scope, as child forks are created, which receive from this source, send to the resulting one, and run the mappings.

Value parameters

f

The mapping function.

parallelism

An upper bound on the number of forks that run in parallel. Each fork runs the function f on a single element of the source.

Attributes

Returns

A source, onto which results of the mapping function will be sent.

def mapParUnordered[U](parallelism: Int)(f: T => U)(using Ox, StageCapacity): Source[U]
def merge[U >: T](other: Source[U])(using Ox, StageCapacity): Source[U]
def pipeTo(sink: Sink[T]): Unit
def take(n: Int)(using Ox, StageCapacity): Source[T]
def toList: List[T]
def transform[U](f: Iterator[T] => Iterator[U])(using Ox, StageCapacity): Source[U]
def zip[U](other: Source[U])(using Ox, StageCapacity): Source[(T, U)]
Generated with