Flow

Turn a CompletionStage<Flow> into a flow that will consume the values of the source when the future completes successfully. If the Future is completed with a failure the stream is failed.

The materialized completion stage value is completed with the materialized value of the future flow or failed with a NeverMaterializedException if upstream fails or downstream cancels before the completion stage has completed.

Create a Flow which can process elements of type T.

Collect the value of Optional from the elements passing through this flow, empty Optional is filtered out.

Adheres to the ActorAttributes.SupervisionStrategy attribute.

'''Emits when''' the current Optional's value is present.

'''Backpressures when''' the value of the current Optional is present and downstream backpressures

'''Completes when''' upstream completes

'''Cancels when''' downstream cancels *

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.

Defers the creation of a Flow until materialization. The factory function exposes Materializer which is going to be used during materialization and Attributes of the Flow returned by this method.

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. 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:

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. 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.

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.

Defers invoking the create function to create a future flow until there downstream demand has caused upstream to send a first element.

The materialized future value is completed with the materialized value of the created flow when that has successfully been materialized.

If the create function throws or returns a future that fails the stream is failed, in this case the materialized future value is failed with a NeverMaterializedException.

Note that asynchronous boundaries (and other operators) in the stream may do pre-fetching which counter acts the laziness and can trigger the factory earlier than expected.

'''Emits when''' the internal flow is successfully created and it emits

'''Backpressures when''' the internal flow is successfully created and it backpressures or downstream backpressures

'''Completes when''' upstream completes and all elements have been emitted from the internal flow

'''Cancels when''' downstream cancels

Defers invoking the create function to create a future flow until there is downstream demand and passing that downstream demand upstream triggers the first element.

Note that asynchronous boundaries (and other operators) in the stream may do pre-fetching which counter acts the laziness and can trigger the factory earlier than expected.

'''Emits when''' the internal flow is successfully created and it emits

'''Backpressures when''' the internal flow is successfully created and it backpressures or downstream 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.

Creates a Flow from an existing base Flow outputting an optional element and applying an additional viaFlow only if the element in the stream is defined.

'''Emits when''' the provided viaFlow is runs with defined elements

'''Backpressures when''' the viaFlow runs for the defined elements and downstream backpressures

'''Completes when''' upstream completes

'''Cancels when''' downstream cancels

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.

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

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

Defers the creation of a Flow until materialization. The factory function exposes ActorMaterializer which is going to be used during materialization and Attributes of the Flow returned by this method.