Create a Flow
which can process elements of type T
.
Creates a [Flow] which will use the given function to transform its inputs to outputs.
Creates a [Flow] which will use the given function to transform its inputs to outputs. It is equivalent
to Flow.create[T].map(f)
A graph with the shape of a flow logically is a flow, this method makes it so also in type.
Creates a Flow
from a Sink
and a Source
where the Flow's input
will be sent to the Sink and the Flow's output will come from the Source.
Creates a Flow
from a Sink
and a Source
where the Flow's input
will be sent to the Sink and the Flow's output will come from the Source.
The resulting flow can be visualized as:
+----------------------------------------------+ | Resulting Flow[I, O, NotUsed] | | | | +---------+ +-----------+ | | | | | | | I ~~> | Sink[I] | [no-connection!] | Source[O] | ~~> O | | | | | | | +---------+ +-----------+ | +----------------------------------------------+
The completion of the Sink and Source sides of a Flow constructed using
this method are independent. So if the Sink receives a completion signal,
the Source side will remain unaware of that. If you are looking to couple
the termination signals of the two sides use Flow.fromSinkAndSourceCoupled
instead.
See also fromSinkAndSourceMat when access to materialized values of the parameters is needed.
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them. Similar to Flow.fromSinkAndSource however couples the termination of these two operators.
The resulting flow can be visualized as:
+---------------------------------------------+ | Resulting Flow[I, O, NotUsed] | | | | +---------+ +-----------+ | | | | | | | I ~~> | Sink[I] | ~~~(coupled)~~~ | Source[O] | ~~> O | | | | | | | +---------+ +-----------+ | +---------------------------------------------+
E.g. if the emitted Flow gets a cancellation, the Source of course is cancelled, however the Sink will also be completed. The table below illustrates the effects in detail:
Returned Flow | Sink (in ) |
Source (out ) |
---|---|---|
cause: upstream (sink-side) receives completion | effect: receives completion | effect: receives cancel |
cause: upstream (sink-side) receives error | effect: receives error | effect: receives cancel |
cause: downstream (source-side) receives cancel | effect: completes | effect: receives cancel |
effect: cancels upstream, completes downstream | effect: completes | cause: signals complete |
effect: cancels upstream, errors downstream | effect: receives error | cause: signals error or throws |
effect: cancels upstream, completes downstream | cause: cancels | effect: receives cancel |
See also fromSinkAndSourceCoupledMat when access to materialized values of the parameters is needed.
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them. Similar to Flow.fromSinkAndSource however couples the termination of these two operators.
The resulting flow can be visualized as:
+-----------------------------------------------------+ | Resulting Flow[I, O, M] | | | | +-------------+ +---------------+ | | | | | | | I ~~> | Sink[I, M1] | ~~~(coupled)~~~ | Source[O, M2] | ~~> O | | | | | | | +-------------+ +---------------+ | +-----------------------------------------------------+
E.g. if the emitted Flow gets a cancellation, the Source of course is cancelled, however the Sink will also be completed. The table on Flow.fromSinkAndSourceCoupled illustrates the effects in detail.
The combine
function is used to compose the materialized values of the sink
and source
into the materialized value of the resulting Flow.
Creates a Flow
from a Sink
and a Source
where the Flow's input
will be sent to the Sink and the Flow's output will come from the Source.
Creates a Flow
from a Sink
and a Source
where the Flow's input
will be sent to the Sink and the Flow's output will come from the Source.
The resulting flow can be visualized as:
+-------------------------------------------------------+ | Resulting Flow[I, O, M] | | | | +-------------+ +---------------+ | | | | | | | I ~~> | Sink[I, M1] | [no-connection!] | Source[O, M2] | ~~> O | | | | | | | +-------------+ +---------------+ | +------------------------------------------------------+
The completion of the Sink and Source sides of a Flow constructed using
this method are independent. So if the Sink receives a completion signal,
the Source side will remain unaware of that. If you are looking to couple
the termination signals of the two sides use Flow.fromSinkAndSourceCoupledMat
instead.
The combine
function is used to compose the materialized values of the sink
and source
into the materialized value of the resulting Flow.
Creates a real Flow
upon receiving the first element.
Creates a real Flow
upon receiving the first element. Internal Flow
will not be created
if there are no elements, because of completion, cancellation, or error.
The materialized value of the Flow
is a Future[Option[M]]
that is completed with Some(mat)
when the internal
flow gets materialized or with None
when there where no elements. If the flow materialization (including
the call of the flowFactory
) fails then the future is completed with a failure.
Emits when the internal flow is successfully created and it emits
Backpressures when the internal flow is successfully created and it backpressures
Completes when upstream completes and all elements have been emitted from the internal flow
Cancels when downstream cancels
Create a Flow
which can process elements of type T
.
Upcast a stream of elements to a stream of supertypes of that element.
Upcast a stream of elements to a stream of supertypes of that element. Useful in combination with
fan-in operators where you do not want to pay the cost of casting each element in a map
.
a supertype to the type of element flowing out of the flow
A flow that accepts In
and outputs elements of the super type
Creates a real Flow
upon receiving the first element.
Creates a real Flow
upon receiving the first element. Internal Flow
will not be created
if there are no elements, because of completion, cancellation, or error.
The materialized value of the Flow
is the value that is created by the fallback
function.
Emits when the internal flow is successfully created and it emits
Backpressures when the internal flow is successfully created and it backpressures
Completes when upstream completes and all elements have been emitted from the internal flow
Cancels when downstream cancels
(Since version 2.5.12) Use lazyInitAsync instead. (lazyInitAsync returns a flow with a more useful materialized value.)