Flow

Companion class Flow

object Flow

Source: Flow.scala

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

Flow
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

Value Members

final def !=(arg0: Any): Boolean
Definition Classes
AnyRef → Any
final def ##: Int
Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean
Definition Classes
AnyRef → Any
def apply[T]: Flow[T, T, NotUsed]
Returns a Flow which outputs all its inputs.
final def asInstanceOf[T0]: T0
Definition Classes
Any
def clone(): AnyRef
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
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)
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.
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.
def fromProcessor[I, O](processorFactory: () => Processor[I, O]): Flow[I, O, NotUsed]
Creates a Flow from a Reactive Streams org.reactivestreams.Processor
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.
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.
See also fromSinkAndSourceMat when access to materialized values of the parameters is needed.

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

See also fromSinkAndSourceCoupledMat when access to materialized values of the parameters is needed.

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.
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.
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.
The operator's default behavior in case of downstream cancellation before nested flow materialization (future completion) is to cancel immediately. This behavior can be controlled by setting the pekko.stream.Attributes.NestedMaterializationCancellationPolicy.PropagateToNested attribute, this will delay downstream cancellation until nested flow's materialization which is then immediately cancelled (with the original cancellation cause).
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate() @native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate() @native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
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 (see below)
The operator's default behavior in case of downstream cancellation before nested flow materialization (future completion) is to cancel immediately. This behavior can be controlled by setting the pekko.stream.Attributes.NestedMaterializationCancellationPolicy.PropagateToNested attribute, this will delay downstream cancellation until nested flow's materialization which is then immediately cancelled (with the original cancellation cause).
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 (see below)
The operator's default behavior in case of downstream cancellation before nested flow materialization (future completion) is to cancel immediately. This behavior can be controlled by setting the pekko.stream.Attributes.NestedMaterializationCancellationPolicy.PropagateToNested attribute, this will delay downstream cancellation until nested flow's materialization which is then immediately cancelled (with the original cancellation cause).
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @native()
def optionalVia[FIn, FOut, FViaOut, FMat, FViaMat, Mat](flow: Flow[FIn, Option[FOut], FMat], viaFlow: Flow[FOut, FViaOut, FViaMat])(combine: (FMat, FViaMat) => Mat): Flow[FIn, Option[FViaOut], Mat]
Creates a FlowW from an existing base Flow outputting an optional element and applying an additional viaFlow only if the element in the stream is defined.
Creates a FlowW 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 runs with defined elements
Backpressures when the viaFlow runs for the defined elements and downstream backpressures
Completes when upstream completes
Cancels when downstream cancels
flow
The base flow that outputs an optional element
viaFlow
The flow that gets used if the optional element in is defined.
combine
How to combine the materialized values of flow and viaFlow
returns
a Flow with the viaFlow applied onto defined elements of the flow. The output value is contained within an Option which indicates whether the original flow's element had viaFlow applied.
Since
1.1.0
final def synchronized[T0](arg0: => T0): T0
Definition Classes
AnyRef
def toString(): String
Definition Classes
AnyRef → Any
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()
final def wait(): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable]) @Deprecated
Deprecated
(Since version 9)
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 (see below)
The operator's default behavior in case of downstream cancellation before nested flow materialization (future completion) is to cancel immediately. This behavior can be controlled by setting the pekko.stream.Attributes.NestedMaterializationCancellationPolicy.PropagateToNested attribute, this will delay downstream cancellation until nested flow's materialization which is then immediately cancelled (with the original cancellation cause).
Annotations
@deprecated
Deprecated
(Since version Akka 2.6.0) Use 'Flow.futureFlow' in combination with prefixAndTail(1) instead, see futureFlow operator docs for details
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 (see below)
The operator's default behavior in case of downstream cancellation before nested flow materialization (future completion) is to cancel immediately. This behavior can be controlled by setting the pekko.stream.Attributes.NestedMaterializationCancellationPolicy.PropagateToNested attribute, this will delay downstream cancellation until nested flow's materialization which is then immediately cancelled (with the original cancellation cause).
Annotations
@deprecated
Deprecated
(Since version Akka 2.6.0) Use 'Flow.lazyFutureFlow' instead
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 Akka 2.6.0) Use 'fromMaterializer' instead

Packages

Flow

Companion class Flow

object Flow

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Flow

Companion class Flow

object Flow

Value Members

Deprecated Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Flow