Package org.apache.pekko.stream.scaladsl

Class Flow$

java.lang.Object
org.apache.pekko.stream.scaladsl.Flow$
public class Flow$ extends Object

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final Flow$
    MODULE$
    Static reference to the singleton instance of this Scala object.

  • Constructor Summary

    Constructors
    Constructor
    Description
    Flow$()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    <T> Flow<T,T,NotUsed>
    apply()
    Returns a Flow 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.
    <T, U, M> Flow<T,U,scala.concurrent.Future<M>>
    fromMaterializer(scala.Function2<Materializer,Attributes,Flow<T,U,M>> factory)
    Defers the creation of a Flow until materialization.
    <I, O> Flow<I,O,NotUsed>
    fromProcessor(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)
    Creates a Flow from a Reactive Streams Processor
    <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 Streams Processor and returns a materialized value.
    <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, 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 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,scala.concurrent.Future<M>>
    futureFlow(scala.concurrent.Future<Flow<I,O,M>> flow)
    Turn a Future[Flow] into a flow that will consume the values of the source when the future completes successfully.
    <I, O, M> Flow<I,O,scala.concurrent.Future<M>>
    lazyFlow(scala.Function0<Flow<I,O,M>> create)
    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.
    <I, O, M> Flow<I,O,scala.concurrent.Future<M>>
    lazyFutureFlow(scala.Function0<scala.concurrent.Future<Flow<I,O,M>>> create)
    Defers invoking the create function to create a future flow until there downstream demand has caused upstream to send a first element.
    <FIn, FOut, FViaOut, FMat, FViaMat, Mat>
    Flow<FIn,scala.Option<FViaOut>,Mat>
    optionalVia(Flow<FIn,scala.Option<FOut>,FMat> flow, Flow<FOut,FViaOut,FViaMat> viaFlow, scala.Function2<FMat,FViaMat,Mat> combine)
    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.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

    • MODULE$

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

  • Constructor Details

    • Flow$

      public Flow$()

  • Method Details

    • fromProcessor

      public <I, O> Flow<I,O,NotUsed> fromProcessor(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)
      Creates a Flow from a Reactive Streams Processor

    • 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 Streams Processor and returns a materialized value.

    • apply

      public <T> Flow<T,T,NotUsed> apply()
      Returns a Flow which outputs all its inputs.

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

    • optionalVia

      public <FIn, FOut, FViaOut, FMat, FViaMat, Mat> Flow<FIn,scala.Option<FViaOut>,Mat> optionalVia(Flow<FIn,scala.Option<FOut>,FMat> flow, Flow<FOut,FViaOut,FViaMat> viaFlow, scala.Function2<FMat,FViaMat,Mat> combine)
      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

      Parameters:
      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

    • 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.

    • fromMaterializer

      public <T, U, M> Flow<T,U,scala.concurrent.Future<M>> fromMaterializer(scala.Function2<Materializer,Attributes,Flow<T,U,M>> factory)
      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.

    • 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(org.apache.pekko.stream.Graph<org.apache.pekko.stream.SinkShape<I>,M1>,org.apache.pekko.stream.Graph<org.apache.pekko.stream.SourceShape<O>,M2>,scala.Function2<M1,M2,M>) when access to materialized values of the parameters is needed.

    • 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 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.

    • 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

      See also <I,O,M1,M2,M>fromSinkAndSourceCoupledMat(org.apache.pekko.stream.Graph<org.apache.pekko.stream.SinkShape<I>,M1>,org.apache.pekko.stream.Graph<org.apache.pekko.stream.SourceShape<O>,M2>,scala.Function2<M1,M2,M>) when access to materialized values of the parameters is needed.

    • 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 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.

    • futureFlow

      public <I, O, M> Flow<I,O,scala.concurrent.Future<M>> futureFlow(scala.concurrent.Future<Flow<I,O,M>> flow)
      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).

    • lazyFlow

      public <I, O, M> Flow<I,O,scala.concurrent.Future<M>> lazyFlow(scala.Function0<Flow<I,O,M>> create)
      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).

    • lazyFutureFlow

      public <I, O, M> Flow<I,O,scala.concurrent.Future<M>> lazyFutureFlow(scala.Function0<scala.concurrent.Future<Flow<I,O,M>>> create)
      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).