object Flow
- Source
- Flow.scala
- Alphabetic
- By Inheritance
- Flow
- AnyRef
- Any
- Hide All
- Show All
- 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
- 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()
- def completionStageFlow[I, O, M](flow: CompletionStage[Flow[I, O, M]]): Flow[I, O, CompletionStage[M]]
Turn a
CompletionStage<Flow>
into a flow that will consume the values of the source when the future completes successfully.Turn a
CompletionStage<Flow>
into a flow that will consume the values of the source when the future completes successfully. If theFuture
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.
- def create[T](): Flow[T, T, NotUsed]
Create a
Flow
which can process elements of typeT
. - final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def flattenOptional[Out, In <: Optional[Out]](): Flow[In, Out, NotUsed]
Collect the value of Optional from the elements passing through this flow, empty Optional is filtered out.
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 *
- def fromFunction[I, O](f: Function[I, O]): Flow[I, O, 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.create[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[I, O, M](factory: BiFunction[Materializer, Attributes, Flow[I, O, M]]): Flow[I, O, CompletionStage[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: Creator[Processor[I, O]]): Flow[I, O, NotUsed]
- def fromProcessorMat[I, O, Mat](processorFactory: Creator[Pair[Processor[I, O], Mat]]): Flow[I, O, Mat]
- def fromSinkAndSource[I, O](sink: Graph[SinkShape[I], _], source: Graph[SourceShape[O], _]): Flow[I, O, NotUsed]
Creates a
Flow
from aSink
and aSource
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 aSink
and aSource
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: Function2[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 thesink
andsource
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: Function2[M1, M2, M]): Flow[I, O, M]
Creates a
Flow
from aSink
and aSource
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 aSink
and aSource
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 thesink
andsource
into the materialized value of the resulting Flow. - 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 lazyCompletionStageFlow[I, O, M](create: Creator[CompletionStage[Flow[I, O, M]]]): Flow[I, O, CompletionStage[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
- def lazyFlow[I, O, M](create: Creator[Flow[I, O, M]]): Flow[I, O, CompletionStage[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.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
- 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 of[T](clazz: Class[T]): Flow[T, T, NotUsed]
Create a
Flow
which can process elements of typeT
. - final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- def upcast[In, SuperOut, Out <: SuperOut, M](flow: Flow[In, Out, M]): Flow[In, SuperOut, M]
Upcast a stream of elements to a stream of supertypes of that element.
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
.- SuperOut
a supertype to the type of element flowing out of the flow
- returns
A flow that accepts
In
and outputs elements of the super type
- 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: Function[I, CompletionStage[Flow[I, O, M]]], fallback: Creator[M]): Flow[I, O, M]
Creates a real
Flow
upon receiving the first element.Creates a real
Flow
upon receiving the first element. InternalFlow
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 thefallback
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 Akka 2.6.0) Use 'Flow.completionStageFlow' in combination with prefixAndTail(1) instead, see
completionStageFlow
operator docs for details
- def lazyInitAsync[I, O, M](flowFactory: Creator[CompletionStage[Flow[I, O, M]]]): Flow[I, O, CompletionStage[Optional[M]]]
Creates a real
Flow
upon receiving the first element.Creates a real
Flow
upon receiving the first element. InternalFlow
will not be created if there are no elements, because of completion, cancellation, or error.The materialized value of the
Flow
is aFuture[Option[M]]
that is completed withSome(mat)
when the internal flow gets materialized or withNone
when there where no elements. If the flow materialization (including the call of theflowFactory
) 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 Akka 2.6.0) Use 'Flow.lazyCompletionStageFlow' instead
- def setup[I, O, M](factory: BiFunction[ActorMaterializer, Attributes, Flow[I, O, M]]): Flow[I, O, CompletionStage[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