java.lang.Object
- akka.stream.javadsl.Flow$

```
public class Flow$
extends java.lang.Object
```
Create a `Flow` which can process elements of type `T`.

Field Summary

Fields
Modifier and Type Field Description

static Flow$ MODULE$
Static reference to the singleton instance of this Scala object.

Constructor Summary

Constructors
Constructor Description

Flow$()

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`<T> Flow<T,T,NotUsed>`	`create()`
`<I,O> Flow<I,O,NotUsed>`	`fromFunction(Function<I,O> f)`	Creates a [Flow] which will use the given function to transform its inputs to outputs.
`<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.
`<I,O> Flow<I,O,NotUsed>`	`fromProcessor(Creator<org.reactivestreams.Processor<I,O>> processorFactory)`
`<I,O,Mat> Flow<I,O,Mat>`	`fromProcessorMat(Creator<Pair<org.reactivestreams.Processor<I,O>,Mat>> processorFactory)`
`<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.
`<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.
`<I,O,M1,M2,M> Flow<I,O,M>`	`fromSinkAndSourceCoupledMat(Graph<SinkShape<I>,M1> sink, Graph<SourceShape<O>,M2> source, Function2<M1,M2,M> combine)`	Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
`<I,O,M1,M2,M> Flow<I,O,M>`	`fromSinkAndSourceMat(Graph<SinkShape<I>,M1> sink, Graph<SourceShape<O>,M2> source, 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.
`<I,O,M> Flow<I,O,M>`	`lazyInit(Function<I,java.util.concurrent.CompletionStage<Flow<I,O,M>>> flowFactory, Creator<M> fallback)`	Deprecated. Use lazyInitAsync instead.
`<I,O,M> Flow<I,O,java.util.concurrent.CompletionStage<java.util.Optional<M>>>`	`lazyInitAsync(Creator<java.util.concurrent.CompletionStage<Flow<I,O,M>>> flowFactory)`	Creates a real `Flow` upon receiving the first element.
`<T> Flow<T,T,NotUsed>`	`of(java.lang.Class<T> clazz)`	Create a `Flow` which can process elements of type `T`.
`<I,O,M> Flow<I,O,java.util.concurrent.CompletionStage<M>>`	`setup(java.util.function.BiFunction<ActorMaterializer,Attributes,Flow<I,O,M>> factory)`	Defers the creation of a `Flow` until materialization.
`<In,SuperOut,Out extends SuperOut,M> Flow<In,SuperOut,M>`	`upcast(Flow<In,Out,M> flow)`	Upcast a stream of elements to a stream of supertypes of that element.

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

Field Detail
- MODULE$
```
public static final Flow$ MODULE$
```
  Static reference to the singleton instance of this Scala object.

Constructor Detail
- Flow$
```
public Flow$()
```

Method Detail

create

public <T> Flow<T,T,NotUsed> create()

fromProcessor

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

fromProcessorMat

public <I,O,Mat> Flow<I,O,Mat> fromProcessorMat(Creator<Pair<org.reactivestreams.Processor<I,O>,Mat>> processorFactory)

fromFunction
```
public <I,O> Flow<I,O,NotUsed> fromFunction(Function<I,O> f)
```
Creates a [Flow] which will use the given function to transform its inputs to outputs. It is equivalent to Flow.create[T].map(f)

Parameters:

f - (undocumented)

Returns:

(undocumented)

of

public <T> Flow<T,T,NotUsed> of(java.lang.Class<T> clazz)

Create a `Flow` which can process elements of type `T`.

fromGraph
```
public <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 <I,O,M> Flow<I,O,java.util.concurrent.CompletionStage<M>> setup(java.util.function.BiFunction<ActorMaterializer,Attributes,Flow<I,O,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 <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>,akka.japi.function.Function2<M1,M2,M>) when access to materialized values of the parameters is needed.
Parameters:

sink - (undocumented)

source - (undocumented)

Returns:

(undocumented)

fromSinkAndSourceMat

public <I,O,M1,M2,M> Flow<I,O,M> fromSinkAndSourceMat(Graph<SinkShape<I>,M1> sink,
                                                                                          Graph<SourceShape<O>,M2> source,
                                                                                          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 <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

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

fromSinkAndSourceCoupledMat

public <I,O,M1,M2,M> Flow<I,O,M> fromSinkAndSourceCoupledMat(Graph<SinkShape<I>,M1> sink,
                                                                                                 Graph<SourceShape<O>,M2> source,
                                                                                                 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 <I,O,M> Flow<I,O,M> lazyInit(Function<I,java.util.concurrent.CompletionStage<Flow<I,O,M>>> flowFactory,
                                                            Creator<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 <I,O,M> Flow<I,O,java.util.concurrent.CompletionStage<java.util.Optional<M>>> lazyInitAsync(Creator<java.util.concurrent.CompletionStage<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)

upcast
```
public <In,SuperOut,Out extends SuperOut,M> Flow<In,SuperOut,M> upcast(Flow<In,Out,M> flow)
```
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.

Parameters:

flow - (undocumented)

Returns:

A flow that accepts In and outputs elements of the super type

Class Flow$

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MODULE$

Constructor Detail

Flow$

Method Detail

create

fromProcessor

fromProcessorMat

fromFunction

of

fromGraph

setup

fromSinkAndSource

fromSinkAndSourceMat

fromSinkAndSourceCoupled

fromSinkAndSourceCoupledMat

lazyInit

lazyInitAsync

upcast