Class Flow$


  • public class Flow$
    extends java.lang.Object
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static Flow$ MODULE$
      Static reference to the singleton instance of this Scala object.
    • 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 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.
      <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.
      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 real Flow upon receiving the first element.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • MODULE$

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

      • Flow$

        public Flow$()
    • Method Detail

      • 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
        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 Streams Processor and returns a materialized value.
        Parameters:
        processorFactory - (undocumented)
        Returns:
        (undocumented)
      • apply

        public <T> Flow<T,​T,​NotUsed> apply()
        Returns a Flow 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 to Flow[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)
      • 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(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 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.

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

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

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

        Parameters:
        flowFactory - (undocumented)
        Returns:
        (undocumented)