Class Flow$
- java.lang.Object
-
- akka.stream.scaladsl.Flow$
-
public class Flow$ extends java.lang.Object
Creates a Flow from a Reactive StreamsProcessor
-
-
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>
apply()
Returns aFlow
which outputs all its inputs.<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.<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(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)
Creates a Flow from a Reactive StreamsProcessor
<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 StreamsProcessor
and returns a materialized value.<I,O>
Flow<I,O,NotUsed>fromSinkAndSource(Graph<SinkShape<I>,?> sink, Graph<SourceShape<O>,?> source)
Creates aFlow
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.<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, scala.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, scala.Function2<M1,M2,M> combine)
Creates aFlow
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.LinearTraversalBuilder
identityTraversalBuilder()
<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.<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 realFlow
upon receiving the first element.<T,U,M>
Flow<T,U,scala.concurrent.Future<M>>setup(scala.Function2<ActorMaterializer,Attributes,Flow<T,U,M>> factory)
Defers the creation of aFlow
until materialization.
-
-
-
Field Detail
-
MODULE$
public static final Flow$ MODULE$
Static reference to the singleton instance of this Scala object.
-
-
Method Detail
-
identityTraversalBuilder
public LinearTraversalBuilder identityTraversalBuilder()
-
fromProcessor
public <I,O> Flow<I,O,NotUsed> fromProcessor(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)
Creates a Flow from a Reactive StreamsProcessor
- Parameters:
processorFactory
- (undocumented)- Returns:
- (undocumented)
-
fromProcessorMat
public <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 StreamsProcessor
and returns a materialized value.- Parameters:
processorFactory
- (undocumented)- Returns:
- (undocumented)
-
apply
public <T> Flow<T,T,NotUsed> apply()
Returns aFlow
which outputs all its inputs.- Returns:
- (undocumented)
-
fromFunction
public <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 toFlow[T].map(f)
- Parameters:
f
- (undocumented)- Returns:
- (undocumented)
-
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 <T,U,M> Flow<T,U,scala.concurrent.Future<M>> setup(scala.Function2<ActorMaterializer,Attributes,Flow<T,U,M>> factory)
Defers the creation of aFlow
until materialization. Thefactory
function exposesActorMaterializer
which is going to be used during materialization andAttributes
of theFlow
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 aFlow
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
<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 <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 aFlow
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 resultingFlow
.- 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 toFlow.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, theSource
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 <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 toFlow.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, theSource
of course is cancelled, however the Sink will also be completed. The table onFlow.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 resultingFlow
.- Parameters:
sink
- (undocumented)source
- (undocumented)combine
- (undocumented)- Returns:
- (undocumented)
-
lazyInit
public <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 realFlow
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
- Parameters:
flowFactory
- (undocumented)fallback
- (undocumented)- Returns:
- (undocumented)
-
lazyInitAsync
public <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 realFlow
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
- Parameters:
flowFactory
- (undocumented)- Returns:
- (undocumented)
-
-