Class Flow<In,​Out,​Mat>

  • All Implemented Interfaces:
    Graph<FlowShape<In,​Out>,​Mat>, FlowOps<Out,​Mat>, FlowOpsMat<Out,​Mat>

    public final class Flow<In,​Out,​Mat>
    extends java.lang.Object
    implements FlowOpsMat<Out,​Mat>, Graph<FlowShape<In,​Out>,​Mat>
    A Flow is a set of stream processing steps that has one open input and one open output.
    • Method Detail

      • fromProcessor

        public static <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 static <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 static <T> Flow<T,​T,​NotUsed> apply()
        Returns a Flow which outputs all its inputs.
        Returns:
        (undocumented)
      • fromFunction

        public static <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 static <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 static <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 static <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 static <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 static <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 static <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 static <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)
      • recover

        public static <T> FlowOps recover​(scala.PartialFunction<java.lang.Throwable,​T> pf)
      • recoverWithRetries

        public static <T> FlowOps recoverWithRetries​(int attempts,
                                                     scala.PartialFunction<java.lang.Throwable,​Graph<SourceShape<T>,​NotUsed>> pf)
      • mapError

        public static FlowOps mapError​(scala.PartialFunction<java.lang.Throwable,​java.lang.Throwable> pf)
      • map

        public static <T> FlowOps map​(scala.Function1<Out,​T> f)
      • wireTap

        public static FlowOps wireTap​(scala.Function1<Out,​scala.runtime.BoxedUnit> f)
      • mapConcat

        public static <T> FlowOps mapConcat​(scala.Function1<Out,​scala.collection.immutable.Iterable<T>> f)
      • statefulMapConcat

        public static <T> FlowOps statefulMapConcat​(scala.Function0<scala.Function1<Out,​scala.collection.immutable.Iterable<T>>> f)
      • mapAsync

        public static <T> FlowOps mapAsync​(int parallelism,
                                           scala.Function1<Out,​scala.concurrent.Future<T>> f)
      • mapAsyncUnordered

        public static <T> FlowOps mapAsyncUnordered​(int parallelism,
                                                    scala.Function1<Out,​scala.concurrent.Future<T>> f)
      • ask

        public static <S> FlowOps ask​(int parallelism,
                                      ActorRef ref,
                                      Timeout timeout,
                                      scala.reflect.ClassTag<S> tag)
      • filter

        public static FlowOps filter​(scala.Function1<Out,​java.lang.Object> p)
      • filterNot

        public static FlowOps filterNot​(scala.Function1<Out,​java.lang.Object> p)
      • takeWhile

        public static FlowOps takeWhile​(scala.Function1<Out,​java.lang.Object> p)
      • takeWhile

        public static FlowOps takeWhile​(scala.Function1<Out,​java.lang.Object> p,
                                        boolean inclusive)
      • dropWhile

        public static FlowOps dropWhile​(scala.Function1<Out,​java.lang.Object> p)
      • collect

        public static <T> FlowOps collect​(scala.PartialFunction<Out,​T> pf)
      • collectType

        public static <T> FlowOps collectType​(scala.reflect.ClassTag<T> tag)
      • grouped

        public static FlowOps grouped​(int n)
      • limit

        public static FlowOps limit​(long max)
      • limitWeighted

        public static <T> FlowOps limitWeighted​(long max,
                                                scala.Function1<Out,​java.lang.Object> costFn)
      • sliding

        public static FlowOps sliding​(int n,
                                      int step)
      • sliding$default$2

        public static int sliding$default$2()
      • scan

        public static <T> FlowOps scan​(T zero,
                                       scala.Function2<T,​Out,​T> f)
      • scanAsync

        public static <T> FlowOps scanAsync​(T zero,
                                            scala.Function2<T,​Out,​scala.concurrent.Future<T>> f)
      • fold

        public static <T> FlowOps fold​(T zero,
                                       scala.Function2<T,​Out,​T> f)
      • foldAsync

        public static <T> FlowOps foldAsync​(T zero,
                                            scala.Function2<T,​Out,​scala.concurrent.Future<T>> f)
      • reduce

        public static <T> FlowOps reduce​(scala.Function2<T,​T,​T> f)
      • intersperse

        public static <T> FlowOps intersperse​(T start,
                                              T inject,
                                              T end)
      • intersperse

        public static <T> FlowOps intersperse​(T inject)
      • groupedWithin

        public static FlowOps groupedWithin​(int n,
                                            scala.concurrent.duration.FiniteDuration d)
      • groupedWeightedWithin

        public static FlowOps groupedWeightedWithin​(long maxWeight,
                                                    scala.concurrent.duration.FiniteDuration d,
                                                    scala.Function1<Out,​java.lang.Object> costFn)
      • drop

        public static FlowOps drop​(long n)
      • dropWithin

        public static FlowOps dropWithin​(scala.concurrent.duration.FiniteDuration d)
      • take

        public static FlowOps take​(long n)
      • takeWithin

        public static FlowOps takeWithin​(scala.concurrent.duration.FiniteDuration d)
      • conflateWithSeed

        public static <S> FlowOps conflateWithSeed​(scala.Function1<Out,​S> seed,
                                                   scala.Function2<S,​Out,​S> aggregate)
      • conflate

        public static <O2> FlowOps conflate​(scala.Function2<O2,​O2,​O2> aggregate)
      • batch

        public static <S> FlowOps batch​(long max,
                                        scala.Function1<Out,​S> seed,
                                        scala.Function2<S,​Out,​S> aggregate)
      • batchWeighted

        public static <S> FlowOps batchWeighted​(long max,
                                                scala.Function1<Out,​java.lang.Object> costFn,
                                                scala.Function1<Out,​S> seed,
                                                scala.Function2<S,​Out,​S> aggregate)
      • expand

        public static <U> FlowOps expand​(scala.Function1<Out,​scala.collection.Iterator<U>> expander)
      • extrapolate

        public static <U> FlowOps extrapolate​(scala.Function1<U,​scala.collection.Iterator<U>> extrapolator,
                                              scala.Option<U> initial)
      • extrapolate$default$2

        public static <U> scala.None$ extrapolate$default$2()
      • prefixAndTail

        public static <U> FlowOps prefixAndTail​(int n)
      • groupBy

        public static <K> SubFlow<Out,​Mat,​FlowOps,​java.lang.Object> groupBy​(int maxSubstreams,
                                                                                              scala.Function1<Out,​K> f,
                                                                                              boolean allowClosedSubstreamRecreation)
      • groupBy

        public static <K> SubFlow<Out,​Mat,​FlowOps,​java.lang.Object> groupBy​(int maxSubstreams,
                                                                                              scala.Function1<Out,​K> f)
      • splitWhen

        public static SubFlow<Out,​Mat,​FlowOps,​java.lang.Object> splitWhen​(SubstreamCancelStrategy substreamCancelStrategy,
                                                                                            scala.Function1<Out,​java.lang.Object> p)
      • splitWhen

        public static SubFlow<Out,​Mat,​FlowOps,​java.lang.Object> splitWhen​(scala.Function1<Out,​java.lang.Object> p)
      • splitAfter

        public static SubFlow<Out,​Mat,​FlowOps,​java.lang.Object> splitAfter​(SubstreamCancelStrategy substreamCancelStrategy,
                                                                                             scala.Function1<Out,​java.lang.Object> p)
      • splitAfter

        public static SubFlow<Out,​Mat,​FlowOps,​java.lang.Object> splitAfter​(scala.Function1<Out,​java.lang.Object> p)
      • flatMapConcat

        public static <T,​M> FlowOps flatMapConcat​(scala.Function1<Out,​Graph<SourceShape<T>,​M>> f)
      • flatMapMerge

        public static <T,​M> FlowOps flatMapMerge​(int breadth,
                                                       scala.Function1<Out,​Graph<SourceShape<T>,​M>> f)
      • initialTimeout

        public static FlowOps initialTimeout​(scala.concurrent.duration.FiniteDuration timeout)
      • completionTimeout

        public static FlowOps completionTimeout​(scala.concurrent.duration.FiniteDuration timeout)
      • idleTimeout

        public static FlowOps idleTimeout​(scala.concurrent.duration.FiniteDuration timeout)
      • backpressureTimeout

        public static FlowOps backpressureTimeout​(scala.concurrent.duration.FiniteDuration timeout)
      • keepAlive

        public static <U> FlowOps keepAlive​(scala.concurrent.duration.FiniteDuration maxIdle,
                                            scala.Function0<U> injectedElem)
      • throttle

        public static FlowOps throttle​(int elements,
                                       scala.concurrent.duration.FiniteDuration per)
      • throttle

        public static FlowOps throttle​(int elements,
                                       scala.concurrent.duration.FiniteDuration per,
                                       int maximumBurst,
                                       ThrottleMode mode)
      • throttle

        public static FlowOps throttle​(int cost,
                                       scala.concurrent.duration.FiniteDuration per,
                                       scala.Function1<Out,​java.lang.Object> costCalculation)
      • throttle

        public static FlowOps throttle​(int cost,
                                       scala.concurrent.duration.FiniteDuration per,
                                       int maximumBurst,
                                       scala.Function1<Out,​java.lang.Object> costCalculation,
                                       ThrottleMode mode)
      • throttleEven

        public static FlowOps throttleEven​(int elements,
                                           scala.concurrent.duration.FiniteDuration per,
                                           ThrottleMode mode)
      • throttleEven

        public static FlowOps throttleEven​(int cost,
                                           scala.concurrent.duration.FiniteDuration per,
                                           scala.Function1<Out,​java.lang.Object> costCalculation,
                                           ThrottleMode mode)
      • detach

        public static FlowOps detach()
      • initialDelay

        public static FlowOps initialDelay​(scala.concurrent.duration.FiniteDuration delay)
      • log

        public static FlowOps log​(java.lang.String name,
                                  scala.Function1<Out,​java.lang.Object> extract,
                                  LoggingAdapter log)
      • log$default$2

        public static scala.Function1<Out,​java.lang.Object> log$default$2()
      • log$default$3

        public static LoggingAdapter log$default$3​(java.lang.String name,
                                                   scala.Function1<Out,​java.lang.Object> extract)
      • zipLatestGraph

        protected static <U,​M> Graph<FlowShape<Out,​scala.Tuple2<Out,​U>>,​M> zipLatestGraph​(Graph<SourceShape<U>,​M> that)
      • zipWith

        public static <Out2,​Out3> FlowOps zipWith​(Graph<SourceShape<Out2>,​?> that,
                                                        scala.Function2<Out,​Out2,​Out3> combine)
      • zipWithGraph

        protected static <Out2,​Out3,​M> Graph<FlowShape<Out,​Out3>,​M> zipWithGraph​(Graph<SourceShape<Out2>,​M> that,
                                                                                                         scala.Function2<Out,​Out2,​Out3> combine)
      • zipLatestWith

        public static <Out2,​Out3> FlowOps zipLatestWith​(Graph<SourceShape<Out2>,​?> that,
                                                              scala.Function2<Out,​Out2,​Out3> combine)
      • zipLatestWithGraph

        protected static <Out2,​Out3,​M> Graph<FlowShape<Out,​Out3>,​M> zipLatestWithGraph​(Graph<SourceShape<Out2>,​M> that,
                                                                                                               scala.Function2<Out,​Out2,​Out3> combine)
      • zipWithIndex

        public static FlowOps zipWithIndex()
      • interleave

        public static <U> FlowOps interleave​(Graph<SourceShape<U>,​?> that,
                                             int segmentSize,
                                             boolean eagerClose)
      • interleaveGraph

        protected static <U,​M> Graph<FlowShape<Out,​U>,​M> interleaveGraph​(Graph<SourceShape<U>,​M> that,
                                                                                           int segmentSize,
                                                                                           boolean eagerClose)
      • interleaveGraph$default$3

        protected static <U,​M> boolean interleaveGraph$default$3()
      • merge$default$2

        public static <U,​M> boolean merge$default$2()
      • mergeSorted

        public static <U,​M> FlowOps mergeSorted​(Graph<SourceShape<U>,​M> that,
                                                      scala.math.Ordering<U> ord)
      • mergeSortedGraph

        protected static <U,​M> Graph<FlowShape<Out,​U>,​M> mergeSortedGraph​(Graph<SourceShape<U>,​M> that,
                                                                                            scala.math.Ordering<U> ord)
      • divertTo

        public static FlowOps divertTo​(Graph<SinkShape<Out>,​?> that,
                                       scala.Function1<Out,​java.lang.Object> when)
      • divertToGraph

        protected static <M> Graph<FlowShape<Out,​Out>,​M> divertToGraph​(Graph<SinkShape<Out>,​M> that,
                                                                                   scala.Function1<Out,​java.lang.Object> when)
      • zipMat

        public static <U,​Mat2,​Mat3> FlowOpsMat zipMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                  scala.Function2<Mat,​Mat2,​Mat3> matF)
      • zipWithMat

        public static <Out2,​Out3,​Mat2,​Mat3> FlowOpsMat zipWithMat​(Graph<SourceShape<Out2>,​Mat2> that,
                                                                                    scala.Function2<Out,​Out2,​Out3> combine,
                                                                                    scala.Function2<Mat,​Mat2,​Mat3> matF)
      • zipLatestMat

        public static <U,​Mat2,​Mat3> FlowOpsMat zipLatestMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                        scala.Function2<Mat,​Mat2,​Mat3> matF)
      • zipLatestWithMat

        public static <Out2,​Out3,​Mat2,​Mat3> FlowOpsMat zipLatestWithMat​(Graph<SourceShape<Out2>,​Mat2> that,
                                                                                          scala.Function2<Out,​Out2,​Out3> combine,
                                                                                          scala.Function2<Mat,​Mat2,​Mat3> matF)
      • mergeMat

        public static <U,​Mat2,​Mat3> FlowOpsMat mergeMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                    boolean eagerComplete,
                                                                    scala.Function2<Mat,​Mat2,​Mat3> matF)
      • mergeMat$default$2

        public static <U,​Mat2,​Mat3> boolean mergeMat$default$2()
      • interleaveMat

        public static <U,​Mat2,​Mat3> FlowOpsMat interleaveMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                         int request,
                                                                         scala.Function2<Mat,​Mat2,​Mat3> matF)
      • interleaveMat

        public static <U,​Mat2,​Mat3> FlowOpsMat interleaveMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                         int request,
                                                                         boolean eagerClose,
                                                                         scala.Function2<Mat,​Mat2,​Mat3> matF)
      • mergeSortedMat

        public static <U,​Mat2,​Mat3> FlowOpsMat mergeSortedMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                          scala.Function2<Mat,​Mat2,​Mat3> matF,
                                                                          scala.math.Ordering<U> ord)
      • concatMat

        public static <U,​Mat2,​Mat3> FlowOpsMat concatMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                     scala.Function2<Mat,​Mat2,​Mat3> matF)
      • prependMat

        public static <U,​Mat2,​Mat3> FlowOpsMat prependMat​(Graph<SourceShape<U>,​Mat2> that,
                                                                      scala.Function2<Mat,​Mat2,​Mat3> matF)
      • orElseMat

        public static <U,​Mat2,​Mat3> FlowOpsMat orElseMat​(Graph<SourceShape<U>,​Mat2> secondary,
                                                                     scala.Function2<Mat,​Mat2,​Mat3> matF)
      • alsoToMat

        public static <Mat2,​Mat3> FlowOpsMat alsoToMat​(Graph<SinkShape<Out>,​Mat2> that,
                                                             scala.Function2<Mat,​Mat2,​Mat3> matF)
      • divertToMat

        public static <Mat2,​Mat3> FlowOpsMat divertToMat​(Graph<SinkShape<Out>,​Mat2> that,
                                                               scala.Function1<Out,​java.lang.Object> when,
                                                               scala.Function2<Mat,​Mat2,​Mat3> matF)
      • wireTapMat

        public static <Mat2,​Mat3> FlowOpsMat wireTapMat​(Graph<SinkShape<Out>,​Mat2> that,
                                                              scala.Function2<Mat,​Mat2,​Mat3> matF)
      • watchTermination

        public static <Mat2> FlowOpsMat watchTermination​(scala.Function2<Mat,​scala.concurrent.Future<Done>,​Mat2> matF)
      • monitor

        public static <Mat2> FlowOpsMat monitor​(scala.Function2<Mat,​FlowMonitor<Out>,​Mat2> combine)
      • monitorMat

        public static <Mat2> FlowOpsMat monitorMat​(scala.Function2<Mat,​FlowMonitor<Out>,​Mat2> combine)
      • traversalBuilder

        public LinearTraversalBuilder traversalBuilder()
        Description copied from interface: Graph
        INTERNAL API.

        Every materializable element must be backed by a stream layout module

        Specified by:
        traversalBuilder in interface Graph<In,​Out>
        Returns:
        (undocumented)
      • shape

        public FlowShape<In,​Out> shape()
        Description copied from interface: Graph
        The shape of a graph is all that is externally visible: its inlets and outlets.
        Specified by:
        shape in interface Graph<In,​Out>
        Returns:
        (undocumented)
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • isIdentity

        public boolean isIdentity()
      • viaMat

        public <T,​Mat2,​Mat3> Flow<In,​T,​Mat3> viaMat​(Graph<FlowShape<Out,​T>,​Mat2> flow,
                                                                            scala.Function2<Mat,​Mat2,​Mat3> combine)
        Description copied from interface: FlowOpsMat
        Transform this Flow by appending the given processing steps.
        
             +---------------------------------+
             | Resulting Flow[In, T, M2]       |
             |                                 |
             |  +------+            +------+   |
             |  |      |            |      |   |
         In ~~> | this |  ~~Out~~>  | flow |  ~~> T
             |  |   Mat|            |     M|   |
             |  +------+            +------+   |
             +---------------------------------+
         
        The combine function is used to compose the materialized values of this flow and that flow into the materialized value of the resulting Flow.

        It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

        Specified by:
        viaMat in interface FlowOpsMat<In,​Out>
        Parameters:
        flow - (undocumented)
        combine - (undocumented)
        Returns:
        (undocumented)
      • to

        public <Mat2> Sink<In,​Mat> to​(Graph<SinkShape<Out>,​Mat2> sink)
        Connect this Flow to a Sink, concatenating the processing steps of both.
        
             +------------------------------+
             | Resulting Sink[In, Mat]      |
             |                              |
             |  +------+          +------+  |
             |  |      |          |      |  |
         In ~~> | flow | ~~Out~~> | sink |  |
             |  |   Mat|          |     M|  |
             |  +------+          +------+  |
             +------------------------------+
         
        The materialized value of the combined Sink will be the materialized value of the current flow (ignoring the given Sink&rsquo;s value), use {@link Flow#toMat[Mat2* toMat} if a different strategy is needed.

        See also <Mat2,Mat3>toMat(akka.stream.Graph<akka.stream.SinkShape<Out>,Mat2>,scala.Function2<Mat,Mat2,Mat3>) when access to materialized values of the parameter is needed.

        Specified by:
        to in interface FlowOps<In,​Out>
        Parameters:
        sink - (undocumented)
        Returns:
        (undocumented)
      • toMat

        public <Mat2,​Mat3> Sink<In,​Mat3> toMat​(Graph<SinkShape<Out>,​Mat2> sink,
                                                           scala.Function2<Mat,​Mat2,​Mat3> combine)
        Connect this Flow to a Sink, concatenating the processing steps of both.
        
             +----------------------------+
             | Resulting Sink[In, M2]     |
             |                            |
             |  +------+        +------+  |
             |  |      |        |      |  |
         In ~~> | flow | ~Out~> | sink |  |
             |  |   Mat|        |     M|  |
             |  +------+        +------+  |
             +----------------------------+
         
        The combine function is used to compose the materialized values of this flow and that Sink into the materialized value of the resulting Sink.

        It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

        Specified by:
        toMat in interface FlowOpsMat<In,​Out>
        Parameters:
        sink - (undocumented)
        combine - (undocumented)
        Returns:
        (undocumented)
      • mapMaterializedValue

        public <Mat2> Flow<In,​Out,​Mat2> mapMaterializedValue​(scala.Function1<Mat,​Mat2> f)
        Transform the materialized value of this Flow, leaving all other properties as they were.
        Specified by:
        mapMaterializedValue in interface FlowOpsMat<In,​Out>
        Parameters:
        f - (undocumented)
        Returns:
        (undocumented)
      • join

        public <Mat2> RunnableGraph<Mat> join​(Graph<FlowShape<Out,​In>,​Mat2> flow)
        Join this Flow to another Flow, by cross connecting the inputs and outputs, creating a RunnableGraph.
        
         +------+        +-------+
         |      | ~Out~> |       |
         | this |        | other |
         |      | <~In~  |       |
         +------+        +-------+
         
        The materialized value of the combined Flow will be the materialized value of the current flow (ignoring the other Flow&rsquo;s value), use {@link Flow#joinMat[Mat2* joinMat} if a different strategy is needed.
        Parameters:
        flow - (undocumented)
        Returns:
        (undocumented)
      • joinMat

        public <Mat2,​Mat3> RunnableGraph<Mat3> joinMat​(Graph<FlowShape<Out,​In>,​Mat2> flow,
                                                             scala.Function2<Mat,​Mat2,​Mat3> combine)
        Join this Flow to another Flow, by cross connecting the inputs and outputs, creating a RunnableGraph
        
         +------+        +-------+
         |      | ~Out~> |       |
         | this |        | other |
         |      | <~In~  |       |
         +------+        +-------+
         
        The combine function is used to compose the materialized values of this flow and that Flow into the materialized value of the resulting Flow.

        It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

        Parameters:
        flow - (undocumented)
        combine - (undocumented)
        Returns:
        (undocumented)
      • join

        public <I2,​O2,​Mat2> Flow<I2,​O2,​Mat> join​(Graph<BidiShape<Out,​O2,​I2,​In>,​Mat2> bidi)
        Join this Flow to a BidiFlow to close off the &ldquo;top&rdquo; of the protocol stack:
        
         +---------------------------+
         | Resulting Flow            |
         |                           |
         | +------+        +------+  |
         | |      | ~Out~> |      | ~~> O2
         | | flow |        | bidi |  |
         | |      | <~In~  |      | <~~ I2
         | +------+        +------+  |
         +---------------------------+
         
        The materialized value of the combined Flow will be the materialized value of the current flow (ignoring the BidiFlow&rsquo;s value), use {@link Flow#joinMat[I2* joinMat} if a different strategy is needed.
        Parameters:
        bidi - (undocumented)
        Returns:
        (undocumented)
      • joinMat

        public <I2,​O2,​Mat2,​M> Flow<I2,​O2,​M> joinMat​(Graph<BidiShape<Out,​O2,​I2,​In>,​Mat2> bidi,
                                                                                  scala.Function2<Mat,​Mat2,​M> combine)
        Join this Flow to a BidiFlow to close off the &ldquo;top&rdquo; of the protocol stack:
        
         +---------------------------+
         | Resulting Flow            |
         |                           |
         | +------+        +------+  |
         | |      | ~Out~> |      | ~~> O2
         | | flow |        | bidi |  |
         | |      | <~In~  |      | <~~ I2
         | +------+        +------+  |
         +---------------------------+
         
        The combine function is used to compose the materialized values of this flow and that BidiFlow into the materialized value of the resulting Flow.

        It is recommended to use the internally optimized Keep.left and Keep.right combiners where appropriate instead of manually writing functions that pass through one of the values.

        Parameters:
        bidi - (undocumented)
        combine - (undocumented)
        Returns:
        (undocumented)
      • withAttributes

        public Flow<In,​Out,​Mat> withAttributes​(Attributes attr)
        Replace the attributes of this Flow with the given ones. If this Flow is a composite of multiple graphs, new attributes on the composite will be less specific than attributes set directly on the individual graphs of the composite.

        Note that this operation has no effect on an empty Flow (because the attributes apply only to the contained processing operators).

        Specified by:
        withAttributes in interface FlowOps<In,​Out>
        Specified by:
        withAttributes in interface Graph<In,​Out>
        Parameters:
        attr - (undocumented)
        Returns:
        (undocumented)
      • addAttributes

        public Flow<In,​Out,​Mat> addAttributes​(Attributes attr)
        Add the given attributes to this Flow. If the specific attribute was already present on this graph this means the added attribute will be more specific than the existing one. If this Flow is a composite of multiple graphs, new attributes on the composite will be less specific than attributes set directly on the individual graphs of the composite.
        Specified by:
        addAttributes in interface FlowOps<In,​Out>
        Specified by:
        addAttributes in interface Graph<In,​Out>
        Parameters:
        attr - (undocumented)
        Returns:
        (undocumented)
      • named

        public Flow<In,​Out,​Mat> named​(java.lang.String name)
        Add a name attribute to this Flow.
        Specified by:
        named in interface FlowOps<In,​Out>
        Specified by:
        named in interface Graph<In,​Out>
        Parameters:
        name - (undocumented)
        Returns:
        (undocumented)
      • async

        public Flow<In,​Out,​Mat> async()
        Put an asynchronous boundary around this Flow
        Specified by:
        async in interface FlowOps<In,​Out>
        Specified by:
        async in interface Graph<In,​Out>
        Returns:
        (undocumented)
      • async

        public Flow<In,​Out,​Mat> async​(java.lang.String dispatcher)
        Put an asynchronous boundary around this Flow

        Specified by:
        async in interface Graph<In,​Out>
        Parameters:
        dispatcher - Run the graph on this dispatcher
        Returns:
        (undocumented)
      • async

        public Flow<In,​Out,​Mat> async​(java.lang.String dispatcher,
                                                  int inputBufferSize)
        Put an asynchronous boundary around this Flow

        Specified by:
        async in interface Graph<In,​Out>
        Parameters:
        dispatcher - Run the graph on this dispatcher
        inputBufferSize - Set the input buffer to this size for the graph
        Returns:
        (undocumented)
      • runWith

        public <Mat1,​Mat2> scala.Tuple2<Mat1,​Mat2> runWith​(Graph<SourceShape<In>,​Mat1> source,
                                                                       Graph<SinkShape<Out>,​Mat2> sink,
                                                                       Materializer materializer)
        Connect the Source to this Flow and then connect it to the Sink and run it. The returned tuple contains the materialized values of the Source and Sink, e.g. the Subscriber of a of a Source#subscriber and and Publisher of a Sink#publisher.
        Parameters:
        source - (undocumented)
        sink - (undocumented)
        materializer - (undocumented)
        Returns:
        (undocumented)
      • toProcessor

        public RunnableGraph<org.reactivestreams.Processor<In,​Out>> toProcessor()
        Converts this Flow to a RunnableGraph that materializes to a Reactive Streams Processor which implements the operations encapsulated by this Flow. Every materialization results in a new Processor instance, i.e. the returned RunnableGraph is reusable.

        Returns:
        A RunnableGraph that materializes to a Processor when run() is called on it.
      • asJava

        public <JIn extends InFlow<JIn,​Out,​Mat> asJava()
        Converts this Scala DSL element to it's Java DSL counterpart.