java.lang.Object
- akka.stream.scaladsl.Flow<In,Out,Mat>

All Implemented Interfaces:

Graph<FlowShape<In,Out>,Mat>, FlowOps<Out,Mat>, FlowOpsMat<Out,Mat>
```
public final class Flow<In,Out,Mat>
extends java.lang.Object
implements FlowOpsMat<Out,Mat>, Graph<FlowShape<In,Out>,Mat>
```
Connect this Flow to a Sink, concatenating the processing steps of both.
```
     +------------------------------+
     | Resulting Sink[In, Mat]      |
     |                              |
     |  +------+          +------+  |
     |  |      |          |      |  |
 In ~~> | flow | ~~Out~~> | sink |  |
     |  |   Mat|          |     M|  |
     |  +------+          +------+  |
     +------------------------------+
 
```
The materialized value of the combined Sink will be the materialized value of the current flow (ignoring the given Sink’s value), use {@link Flow#toMat[Mat2* toMat} if a different strategy is needed.
See also <Mat2,Mat3>toMat(akka.stream.Graph<akka.stream.SinkShape<Out>,Mat2>,scala.Function2<Mat,Mat2,Mat3>) when access to materialized values of the parameter is needed.

Constructor Summary

Constructors
Constructor Description

Flow(LinearTraversalBuilder traversalBuilder, FlowShape<In,Out> shape)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`Flow<In,Out,Mat>`	`addAttributes(Attributes attr)`	Add the given attributes to this `Flow`.
`static <T> Flow<T,T,NotUsed>`	`apply()`	Returns a `Flow` which outputs all its inputs.
`<U,CtxU,CtxOut> FlowWithContext<U,CtxU,Out,CtxOut,Mat>`	`asFlowWithContext(scala.Function2<U,CtxU,In> collapseContext, scala.Function1<Out,CtxOut> extractContext)`	Turns a Flow into a FlowWithContext which manages a context per element along a stream.
`<JIn extends In> Flow<JIn,Out,Mat>`	`asJava()`	Converts this Scala DSL element to it's Java DSL counterpart.
`Flow<In,Out,Mat>`	`async()`	Put an asynchronous boundary around this `Flow`
`Flow<In,Out,Mat>`	`async(java.lang.String dispatcher)`	Put an asynchronous boundary around this `Flow`
`Flow<In,Out,Mat>`	`async(java.lang.String dispatcher, int inputBufferSize)`	Put an asynchronous boundary around this `Flow`
`static <A,B> Flow<A,B,NotUsed>`	`fromFunction(scala.Function1<A,B> f)`	Creates a [Flow] which will use the given function to transform its inputs to outputs.
`static <I,O,M> Flow<I,O,M>`	`fromGraph(Graph<FlowShape<I,O>,M> g)`	A graph with the shape of a flow logically is a flow, this method makes it so also in type.
`static <I,O> Flow<I,O,NotUsed>`	`fromProcessor(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)`	Creates a Flow from a Reactive Streams `Processor`
`static <I,O,M> Flow<I,O,M>`	`fromProcessorMat(scala.Function0<scala.Tuple2<org.reactivestreams.Processor<I,O>,M>> processorFactory)`	Creates a Flow from a Reactive Streams `Processor` and returns a materialized value.
`static <I,O> Flow<I,O,NotUsed>`	`fromSinkAndSource(Graph<SinkShape<I>,?> sink, Graph<SourceShape<O>,?> 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.
`static <I,O> Flow<I,O,NotUsed>`	`fromSinkAndSourceCoupled(Graph<SinkShape<I>,?> sink, Graph<SourceShape<O>,?> source)`	Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
`static <I,O,M1,M2,M> Flow<I,O,M>`	`fromSinkAndSourceCoupledMat(Graph<SinkShape<I>,M1> sink, Graph<SourceShape<O>,M2> source, scala.Function2<M1,M2,M> combine)`	Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
`static <I,O,M1,M2,M> Flow<I,O,M>`	`fromSinkAndSourceMat(Graph<SinkShape<I>,M1> sink, Graph<SourceShape<O>,M2> source, scala.Function2<M1,M2,M> combine)`	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.
`static LinearTraversalBuilder`	`identityTraversalBuilder()`
`boolean`	`isIdentity()`
`<I2,O2,Mat2> Flow<I2,O2,Mat>`	`join(Graph<BidiShape<Out,O2,I2,In>,Mat2> bidi)`	Join this `Flow` to a `BidiFlow` to close off the “top” of the protocol stack:
`<Mat2> RunnableGraph<Mat>`	`join(Graph<FlowShape<Out,In>,Mat2> flow)`	Join this `Flow` to another `Flow`, by cross connecting the inputs and outputs, creating a `RunnableGraph`.
`<I2,O2,Mat2,M> Flow<I2,O2,M>`	`joinMat(Graph<BidiShape<Out,O2,I2,In>,Mat2> bidi, scala.Function2<Mat,Mat2,M> combine)`	Join this `Flow` to a `BidiFlow` to close off the “top” of the protocol stack:
`<Mat2,Mat3> RunnableGraph<Mat3>`	`joinMat(Graph<FlowShape<Out,In>,Mat2> flow, scala.Function2<Mat,Mat2,Mat3> combine)`	Join this `Flow` to another `Flow`, by cross connecting the inputs and outputs, creating a `RunnableGraph`
`static <I,O,M> Flow<I,O,M>`	`lazyInit(scala.Function1<I,scala.concurrent.Future<Flow<I,O,M>>> flowFactory, scala.Function0<M> fallback)`	Deprecated. Use lazyInitAsync instead.
`static <I,O,M> Flow<I,O,scala.concurrent.Future<scala.Option<M>>>`	`lazyInitAsync(scala.Function0<scala.concurrent.Future<Flow<I,O,M>>> flowFactory)`	Creates a real `Flow` upon receiving the first element.
`<Mat2> Flow<In,Out,Mat2>`	`mapMaterializedValue(scala.Function1<Mat,Mat2> f)`	Transform the materialized value of this Flow, leaving all other properties as they were.
`Flow<In,Out,Mat>`	`named(java.lang.String name)`	Add a name attribute to this Flow.
`<Mat1,Mat2> scala.Tuple2<Mat1,Mat2>`	`runWith(Graph<SourceShape<In>,Mat1> source, Graph<SinkShape<Out>,Mat2> sink, Materializer materializer)`	Connect the `Source` to this `Flow` and then connect it to the `Sink` and run it.
`static <T,U,M> Flow<T,U,scala.concurrent.Future<M>>`	`setup(scala.Function2<ActorMaterializer,Attributes,Flow<T,U,M>> factory)`	Defers the creation of a `Flow` until materialization.
`FlowShape<In,Out>`	`shape()`	The shape of a graph is all that is externally visible: its inlets and outlets.
`<Mat2> Sink<In,Mat>`	`to(Graph<SinkShape<Out>,Mat2> sink)`	Connect this `Flow` to a `Sink`, concatenating the processing steps of both.
`<Mat2,Mat3> Sink<In,Mat3>`	`toMat(Graph<SinkShape<Out>,Mat2> sink, scala.Function2<Mat,Mat2,Mat3> combine)`	Connect this `Flow` to a `Sink`, concatenating the processing steps of both.
`RunnableGraph<org.reactivestreams.Processor<In,Out>>`	`toProcessor()`	Converts this Flow to a `RunnableGraph` that materializes to a Reactive Streams `Processor` which implements the operations encapsulated by this Flow.
`java.lang.String`	`toString()`
`LinearTraversalBuilder`	`traversalBuilder()`	INTERNAL API.
`<T,Mat2> Flow<In,T,Mat>`	`via(Graph<FlowShape<Out,T>,Mat2> flow)`
`<T,Mat2,Mat3> Flow<In,T,Mat3>`	`viaMat(Graph<FlowShape<Out,T>,Mat2> flow, scala.Function2<Mat,Mat2,Mat3> combine)`	Transform this `Flow` by appending the given processing steps.
`Flow<In,Out,Mat>`	`withAttributes(Attributes attr)`	Replace the attributes of this `Flow` with the given ones.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface akka.stream.scaladsl.FlowOps
$plus$plus, alsoTo, alsoToGraph, ask, ask, backpressureTimeout, batch, batchWeighted, buffer, collect, collectType, completionTimeout, concat, concatGraph, conflate, conflateWithSeed, delay, delay$default$2, detach, divertTo, divertToGraph, drop, dropWhile, dropWithin, expand, extrapolate, extrapolate$default$2, filter, filterNot, flatMapConcat, flatMapMerge, fold, foldAsync, groupBy, groupBy, grouped, groupedWeightedWithin, groupedWithin, idleTimeout, initialDelay, initialTimeout, interleave, interleave, interleaveGraph, interleaveGraph$default$3, intersperse, intersperse, keepAlive, limit, limitWeighted, log, log$default$2, log$default$3, map, mapAsync, mapAsyncUnordered, mapConcat, mapError, merge, merge$default$2, mergeGraph, mergeSorted, mergeSortedGraph, orElse, orElseGraph, prefixAndTail, prepend, prependGraph, recover, recoverWith, recoverWithRetries, reduce, scan, scanAsync, sliding, sliding$default$2, splitAfter, splitAfter, splitWhen, splitWhen, statefulMapConcat, take, takeWhile, takeWhile, takeWithin, throttle, throttle, throttle, throttle, throttleEven, throttleEven, watch, wireTap, wireTap, wireTapGraph, zip, zipGraph, zipLatest, zipLatestGraph, zipLatestWith, zipLatestWithGraph, zipWith, zipWithGraph, zipWithIndex

Methods inherited from interface akka.stream.scaladsl.FlowOpsMat
alsoToMat, concatMat, divertToMat, interleaveMat, interleaveMat, mergeMat, mergeMat$default$2, mergeSortedMat, monitor, monitor, monitorMat, orElseMat, prependMat, watchTermination, wireTapMat, zipLatestMat, zipLatestWithMat, zipMat, zipWithMat

Constructor Detail

Flow

public Flow(LinearTraversalBuilder traversalBuilder,
            FlowShape<In,Out> shape)

Method Detail

identityTraversalBuilder

public static LinearTraversalBuilder identityTraversalBuilder()

fromProcessor

public static <I,O> Flow<I,O,NotUsed> fromProcessor(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)

Creates a Flow from a Reactive Streams Processor

Parameters:: processorFactory - (undocumented)
Returns:: (undocumented)

fromProcessorMat

public static <I,O,M> Flow<I,O,M> fromProcessorMat(scala.Function0<scala.Tuple2<org.reactivestreams.Processor<I,O>,M>> processorFactory)

Creates a Flow from a Reactive Streams Processor and returns a materialized value.

Parameters:: processorFactory - (undocumented)
Returns:: (undocumented)

apply
```
public static <T> Flow<T,T,NotUsed> apply()
```
Returns a Flow which outputs all its inputs.

Returns:

(undocumented)

fromFunction
```
public static <A,B> Flow<A,B,NotUsed> fromFunction(scala.Function1<A,B> f)
```
Creates a [Flow] which will use the given function to transform its inputs to outputs. It is equivalent to Flow[T].map(f)

Parameters:

f - (undocumented)

Returns:

(undocumented)

fromGraph
```
public static <I,O,M> Flow<I,O,M> fromGraph(Graph<FlowShape<I,O>,M> g)
```
A graph with the shape of a flow logically is a flow, this method makes it so also in type.

Parameters:

g - (undocumented)

Returns:

(undocumented)

setup
```
public static <T,U,M> Flow<T,U,scala.concurrent.Future<M>> setup(scala.Function2<ActorMaterializer,Attributes,Flow<T,U,M>> factory)
```
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.

Parameters:

factory - (undocumented)

Returns:

(undocumented)

fromSinkAndSource
```
public static <I,O> Flow<I,O,NotUsed> fromSinkAndSource(Graph<SinkShape<I>,?> sink,
                                                                          Graph<SourceShape<O>,?> 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 <I,O,M1,M2,M>fromSinkAndSourceMat(akka.stream.Graph<akka.stream.SinkShape<I>,M1>,akka.stream.Graph<akka.stream.SourceShape<O>,M2>,scala.Function2<M1,M2,M>) when access to materialized values of the parameters is needed.
Parameters:

sink - (undocumented)

source - (undocumented)

Returns:

(undocumented)

fromSinkAndSourceMat

public static <I,O,M1,M2,M> Flow<I,O,M> fromSinkAndSourceMat(Graph<SinkShape<I>,M1> sink,
                                                                                                 Graph<SourceShape<O>,M2> source,
                                                                                                 scala.Function2<M1,M2,M> combine)

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.

Parameters:: sink - (undocumented); source - (undocumented); combine - (undocumented)
Returns:: (undocumented)

fromSinkAndSourceCoupled

public static <I,O> Flow<I,O,NotUsed> fromSinkAndSourceCoupled(Graph<SinkShape<I>,?> sink,
                                                                                 Graph<SourceShape<O>,?> source)

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 <I,O,M1,M2,M>fromSinkAndSourceCoupledMat(akka.stream.Graph<akka.stream.SinkShape<I>,M1>,akka.stream.Graph<akka.stream.SourceShape<O>,M2>,scala.Function2<M1,M2,M>) when access to materialized values of the parameters is needed.

Parameters:: sink - (undocumented); source - (undocumented)
Returns:: (undocumented)

fromSinkAndSourceCoupledMat

public static <I,O,M1,M2,M> Flow<I,O,M> fromSinkAndSourceCoupledMat(Graph<SinkShape<I>,M1> sink,
                                                                                                        Graph<SourceShape<O>,M2> source,
                                                                                                        scala.Function2<M1,M2,M> combine)

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.

Parameters:: sink - (undocumented); source - (undocumented); combine - (undocumented)
Returns:: (undocumented)

lazyInit
```
public static <I,O,M> Flow<I,O,M> lazyInit(scala.Function1<I,scala.concurrent.Future<Flow<I,O,M>>> flowFactory,
                                                                   scala.Function0<M> fallback)
```
Deprecated.
Use lazyInitAsync instead. (lazyInitAsync returns a flow with a more useful materialized value.). Since 2.5.12.

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

Parameters:

flowFactory - (undocumented)

fallback - (undocumented)

Returns:

(undocumented)

lazyInitAsync
```
public static <I,O,M> Flow<I,O,scala.concurrent.Future<scala.Option<M>>> lazyInitAsync(scala.Function0<scala.concurrent.Future<Flow<I,O,M>>> flowFactory)
```
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

Parameters:

flowFactory - (undocumented)

Returns:

(undocumented)

traversalBuilder
```
public LinearTraversalBuilder traversalBuilder()
```
Description copied from interface: Graph

INTERNAL API.
Every materializable element must be backed by a stream layout module

Specified by:

traversalBuilder in interface Graph<In,Out>

Returns:

(undocumented)

shape
```
public FlowShape<In,Out> shape()
```
Description copied from interface: Graph

The shape of a graph is all that is externally visible: its inlets and outlets.

Specified by:

shape in interface Graph<In,Out>

Returns:

(undocumented)

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

isIdentity
```
public boolean isIdentity()
```

via

public <T,Mat2> Flow<In,T,Mat> via(Graph<FlowShape<Out,T>,Mat2> flow)

Specified by:: via in interface FlowOps<In,Out>

viaMat

public <T,Mat2,Mat3> Flow<In,T,Mat3> viaMat(Graph<FlowShape<Out,T>,Mat2> flow,
                                                                    scala.Function2<Mat,Mat2,Mat3> combine)

Description copied from interface: FlowOpsMat

Transform this Flow by appending the given processing steps.


     +---------------------------------+
     | Resulting Flow[In, T, M2]       |
     |                                 |
     |  +------+            +------+   |
     |  |      |            |      |   |
 In ~~> | this |  ~~Out~~>  | flow |  ~~> T
     |  |   Mat|            |     M|   |
     |  +------+            +------+   |
     +---------------------------------+

The combine function is used to compose the materialized values of this flow and that flow into the materialized value of the resulting Flow.

It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

Specified by:: viaMat in interface FlowOpsMat<In,Out>
Parameters:: flow - (undocumented); combine - (undocumented)
Returns:: (undocumented)

to
```
public <Mat2> Sink<In,Mat> to(Graph<SinkShape<Out>,Mat2> sink)
```
Connect this Flow to a Sink, concatenating the processing steps of both.
```
     +------------------------------+
     | Resulting Sink[In, Mat]      |
     |                              |
     |  +------+          +------+  |
     |  |      |          |      |  |
 In ~~> | flow | ~~Out~~> | sink |  |
     |  |   Mat|          |     M|  |
     |  +------+          +------+  |
     +------------------------------+
 
```
The materialized value of the combined Sink will be the materialized value of the current flow (ignoring the given Sink’s value), use {@link Flow#toMat[Mat2* toMat} if a different strategy is needed.
See also <Mat2,Mat3>toMat(akka.stream.Graph<akka.stream.SinkShape<Out>,Mat2>,scala.Function2<Mat,Mat2,Mat3>) when access to materialized values of the parameter is needed.
Specified by:

to in interface FlowOps<In,Out>

Parameters:

sink - (undocumented)

Returns:

(undocumented)

toMat

public <Mat2,Mat3> Sink<In,Mat3> toMat(Graph<SinkShape<Out>,Mat2> sink,
                                                   scala.Function2<Mat,Mat2,Mat3> combine)

Connect this Flow to a Sink, concatenating the processing steps of both.


     +----------------------------+
     | Resulting Sink[In, M2]     |
     |                            |
     |  +------+        +------+  |
     |  |      |        |      |  |
 In ~~> | flow | ~Out~> | sink |  |
     |  |   Mat|        |     M|  |
     |  +------+        +------+  |
     +----------------------------+

The combine function is used to compose the materialized values of this flow and that Sink into the materialized value of the resulting Sink.

It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

Specified by:: toMat in interface FlowOpsMat<In,Out>
Parameters:: sink - (undocumented); combine - (undocumented)
Returns:: (undocumented)

mapMaterializedValue
```
public <Mat2> Flow<In,Out,Mat2> mapMaterializedValue(scala.Function1<Mat,Mat2> f)
```
Transform the materialized value of this Flow, leaving all other properties as they were.

Specified by:

mapMaterializedValue in interface FlowOpsMat<In,Out>

Parameters:

f - (undocumented)

Returns:

(undocumented)

join
```
public <Mat2> RunnableGraph<Mat> join(Graph<FlowShape<Out,In>,Mat2> flow)
```
Join this Flow to another Flow, by cross connecting the inputs and outputs, creating a RunnableGraph.
```
 +------+        +-------+
 |      | ~Out~> |       |
 | this |        | other |
 |      | <~In~  |       |
 +------+        +-------+
 
```
The materialized value of the combined Flow will be the materialized value of the current flow (ignoring the other Flow’s value), use {@link Flow#joinMat[Mat2* joinMat} if a different strategy is needed.
Parameters:

flow - (undocumented)

Returns:

(undocumented)

joinMat
```
public <Mat2,Mat3> RunnableGraph<Mat3> joinMat(Graph<FlowShape<Out,In>,Mat2> flow,
                                                     scala.Function2<Mat,Mat2,Mat3> combine)
```
Join this Flow to another Flow, by cross connecting the inputs and outputs, creating a RunnableGraph
```
 +------+        +-------+
 |      | ~Out~> |       |
 | this |        | other |
 |      | <~In~  |       |
 +------+        +-------+
 
```
The combine function is used to compose the materialized values of this flow and that Flow into the materialized value of the resulting Flow.
It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.
Parameters:

flow - (undocumented)

combine - (undocumented)

Returns:

(undocumented)

join

public <I2,O2,Mat2> Flow<I2,O2,Mat> join(Graph<BidiShape<Out,O2,I2,In>,Mat2> bidi)

Join this Flow to a BidiFlow to close off the “top” of the protocol stack:


 +---------------------------+
 | Resulting Flow            |
 |                           |
 | +------+        +------+  |
 | |      | ~Out~> |      | ~~> O2
 | | flow |        | bidi |  |
 | |      | <~In~  |      | <~~ I2
 | +------+        +------+  |
 +---------------------------+

The materialized value of the combined Flow will be the materialized value of the current flow (ignoring the BidiFlow’s value), use {@link Flow#joinMat[I2* joinMat} if a different strategy is needed.

Parameters:: bidi - (undocumented)
Returns:: (undocumented)

joinMat

public <I2,O2,Mat2,M> Flow<I2,O2,M> joinMat(Graph<BidiShape<Out,O2,I2,In>,Mat2> bidi,
                                                                          scala.Function2<Mat,Mat2,M> combine)

Join this Flow to a BidiFlow to close off the “top” of the protocol stack:


 +---------------------------+
 | Resulting Flow            |
 |                           |
 | +------+        +------+  |
 | |      | ~Out~> |      | ~~> O2
 | | flow |        | bidi |  |
 | |      | <~In~  |      | <~~ I2
 | +------+        +------+  |
 +---------------------------+

The combine function is used to compose the materialized values of this flow and that BidiFlow into the materialized value of the resulting Flow.

It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

Parameters:: bidi - (undocumented); combine - (undocumented)
Returns:: (undocumented)

withAttributes
```
public Flow<In,Out,Mat> withAttributes(Attributes attr)
```
Replace the attributes of this Flow with the given ones. If this Flow is a composite of multiple graphs, new attributes on the composite will be less specific than attributes set directly on the individual graphs of the composite.
Note that this operation has no effect on an empty Flow (because the attributes apply only to the contained processing operators).

Specified by:

withAttributes in interface FlowOps<In,Out>

Specified by:

withAttributes in interface Graph<In,Out>

Parameters:

attr - (undocumented)

Returns:

(undocumented)

addAttributes
```
public Flow<In,Out,Mat> addAttributes(Attributes attr)
```
Add the given attributes to this Flow. If the specific attribute was already present on this graph this means the added attribute will be more specific than the existing one. If this Flow is a composite of multiple graphs, new attributes on the composite will be less specific than attributes set directly on the individual graphs of the composite.

Specified by:

addAttributes in interface FlowOps<In,Out>

Specified by:

addAttributes in interface Graph<In,Out>

Parameters:

attr - (undocumented)

Returns:

(undocumented)

named
```
public Flow<In,Out,Mat> named(java.lang.String name)
```
Add a name attribute to this Flow.

Specified by:

named in interface FlowOps<In,Out>

Specified by:

named in interface Graph<In,Out>

Parameters:

name - (undocumented)

Returns:

(undocumented)

async
```
public Flow<In,Out,Mat> async()
```
Put an asynchronous boundary around this Flow

Specified by:

async in interface FlowOps<In,Out>

Specified by:

async in interface Graph<In,Out>

Returns:

(undocumented)

async
```
public Flow<In,Out,Mat> async(java.lang.String dispatcher)
```
Put an asynchronous boundary around this Flow

Specified by:

async in interface Graph<In,Out>

Parameters:

dispatcher - Run the graph on this dispatcher

Returns:

(undocumented)

async
```
public Flow<In,Out,Mat> async(java.lang.String dispatcher,
                                          int inputBufferSize)
```
Put an asynchronous boundary around this Flow

Specified by:

async in interface Graph<In,Out>

Parameters:

dispatcher - Run the graph on this dispatcher

inputBufferSize - Set the input buffer to this size for the graph

Returns:

(undocumented)

runWith

public <Mat1,Mat2> scala.Tuple2<Mat1,Mat2> runWith(Graph<SourceShape<In>,Mat1> source,
                                                               Graph<SinkShape<Out>,Mat2> sink,
                                                               Materializer materializer)

Connect the Source to this Flow and then connect it to the Sink and run it. The returned tuple contains the materialized values of the Source and Sink, e.g. the Subscriber of a of a Source#subscriber and and Publisher of a Sink#publisher.

Parameters:: source - (undocumented); sink - (undocumented); materializer - (undocumented)
Returns:: (undocumented)

toProcessor
```
public RunnableGraph<org.reactivestreams.Processor<In,Out>> toProcessor()
```
Converts this Flow to a RunnableGraph that materializes to a Reactive Streams Processor which implements the operations encapsulated by this Flow. Every materialization results in a new Processor instance, i.e. the returned RunnableGraph is reusable.

Returns:

A RunnableGraph that materializes to a Processor when run() is called on it.

asFlowWithContext
```
public <U,CtxU,CtxOut> FlowWithContext<U,CtxU,Out,CtxOut,Mat> asFlowWithContext(scala.Function2<U,CtxU,In> collapseContext,
                                                                                                                    scala.Function1<Out,CtxOut> extractContext)
```
Turns a Flow into a FlowWithContext which manages a context per element along a stream.

Parameters:

collapseContext - turn each incoming pair of element and context value into an element of this Flow

extractContext - turn each outgoing element of this Flow into an outgoing context value
API MAY CHANGE

Returns:

(undocumented)

asJava
```
public <JIn extends In> Flow<JIn,Out,Mat> asJava()
```
Converts this Scala DSL element to it's Java DSL counterpart.

Class Flow<In,​Out,​Mat>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface akka.stream.scaladsl.FlowOps

Methods inherited from interface akka.stream.scaladsl.FlowOpsMat

Constructor Detail

Flow

Method Detail

identityTraversalBuilder

fromProcessor

fromProcessorMat

apply

fromFunction

fromGraph

setup

fromSinkAndSource

fromSinkAndSourceMat

fromSinkAndSourceCoupled

fromSinkAndSourceCoupledMat

lazyInit

lazyInitAsync

traversalBuilder

shape

toString

isIdentity

via

viaMat

to

toMat

mapMaterializedValue

join

joinMat

join

joinMat

withAttributes

addAttributes

named

async

async

async

runWith

toProcessor

asFlowWithContext

asJava

Class Flow<In,Out,Mat>