o

Flow 

Companion class Flow

object Flow

Source
Flow.scala
Linear Supertypes
Ordering
1. Alphabetic
2. By Inheritance
Inherited
1. Flow
2. AnyRef
3. Any
1. Hide All
2. Show All
Visibility
1. Public
2. All

Value Members

1. final def !=(arg0: Any)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. def apply[T]: Flow[T, T, NotUsed]

Returns a `Flow` which outputs all its inputs.

5. final def asInstanceOf[T0]: T0
Definition Classes
Any
6. def clone()
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native() @HotSpotIntrinsicCandidate()
7. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
8. def equals(arg0: Any)
Definition Classes
AnyRef → Any
9. def fromFunction[A, B](f: (A) ⇒ B): Flow[A, B, NotUsed]

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[T].map(f)`

10. def fromGraph[I, O, M](g: Graph[FlowShape[I, O], M]): Flow[I, O, M]

A graph with the shape of a flow logically is a flow, this method makes it so also in type.

11. def fromMaterializer[T, U, M](factory: (Materializer, Attributes) ⇒ Flow[T, U, M]): Flow[T, U, Future[M]]

Defers the creation of a Flow until materialization.

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.

12. def fromProcessor[I, O](processorFactory: () ⇒ Processor[I, O]): Flow[I, O, NotUsed]

Creates a Flow from a Reactive Streams org.reactivestreams.Processor

13. def fromProcessorMat[I, O, M](processorFactory: () ⇒ (Processor[I, O], M)): Flow[I, O, M]

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

14. def fromSinkAndSource[I, O](sink: Graph[SinkShape[I], _], source: Graph[SourceShape[O], _]): Flow[I, O, NotUsed]

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.

15. def fromSinkAndSourceCoupled[I, O](sink: Graph[SinkShape[I], _], source: Graph[SourceShape[O], _]): Flow[I, O, NotUsed]

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

16. def fromSinkAndSourceCoupledMat[I, O, M1, M2, M](sink: Graph[SinkShape[I], M1], source: Graph[SourceShape[O], M2])(combine: (M1, M2) ⇒ M): Flow[I, O, M]

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.

17. def fromSinkAndSourceMat[I, O, M1, M2, M](sink: Graph[SinkShape[I], M1], source: Graph[SourceShape[O], M2])(combine: (M1, M2) ⇒ M): Flow[I, O, M]

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.

18. def futureFlow[I, O, M](flow: Future[Flow[I, O, M]]): Flow[I, O, Future[M]]

Turn a `Future[Flow]` into a flow that will consume the values of the source when the future completes successfully.

Turn a `Future[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 future value is completed with the materialized value of the future flow or failed with a NeverMaterializedException if upstream fails or downstream cancels before the future has completed.

19. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
Annotations
@native() @HotSpotIntrinsicCandidate()
20. def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native() @HotSpotIntrinsicCandidate()
21. final def isInstanceOf[T0]
Definition Classes
Any
22. def lazyFlow[I, O, M](create: () ⇒ Flow[I, O, M]): Flow[I, O, Future[M]]

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.

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.

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

23. def lazyFutureFlow[I, O, M](create: () ⇒ Future[Flow[I, O, M]]): Flow[I, O, Future[M]]

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

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

24. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
25. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
26. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native() @HotSpotIntrinsicCandidate()
27. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
28. def toString()
Definition Classes
AnyRef → Any
29. final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )
30. final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
31. final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

1. def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] ) @Deprecated @deprecated
Deprecated

2. def lazyInit[I, O, M](flowFactory: (I) ⇒ Future[Flow[I, O, M]], fallback: () ⇒ M): Flow[I, O, M]

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

Annotations
@deprecated
Deprecated

(Since version 2.6.0) Use 'Flow.futureFlow' in combination with prefixAndTail(1) instead, see `futureFlow` operator docs for details

3. def lazyInitAsync[I, O, M](flowFactory: () ⇒ Future[Flow[I, O, M]]): Flow[I, O, Future[Option[M]]]

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

Annotations
@deprecated
Deprecated

(Since version 2.6.0) Use 'Flow.lazyFutureFlow' instead

4. def setup[T, U, M](factory: (ActorMaterializer, Attributes) ⇒ Flow[T, U, M]): Flow[T, U, Future[M]]

Defers the creation of a Flow until materialization.

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.

Annotations
@deprecated
Deprecated

(Since version 2.6.0) Use 'fromMaterializer' instead