Flow

java.lang.Object
- akka.stream.scaladsl.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.

Constructor Summary

Constructors
Constructor and Description

Flow(StreamLayout.Module module)

Constructors
Constructor and Description
`Flow(StreamLayout.Module module)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <U,M> FlowOps`	`$plus$plus(Graph<SourceShape<U>,M> that)`
`Flow<In,Out,Mat>`	`addAttributes(Attributes attr)` Add the given attributes to this Flow.
`static FlowOps`	`alsoTo(Graph<SinkShape<Out>,?> that)`
`protected static <M> Graph<FlowShape<Out,Out>,M>`	`alsoToGraph(Graph<SinkShape<Out>,M> that)`
`static <Mat2,Mat3> FlowOpsMat`	`alsoToMat(Graph<SinkShape<Out>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> FlowOps`	`andThen(Stages.SymbolicStage<Out,T> op)`
`static <T> Flow<T,T,NotUsed>`	`apply()` Returns a `Flow` which outputs all its inputs.
`Flow<In,Out,Mat>`	`asJava()` Converts this Scala DSL element to it's Java DSL counterpart.
`Flow<In,Out,Mat>`	`async()` Put an asynchronous boundary around this `Flow`
`static FlowOps`	`backpressureTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static <S> FlowOps`	`batch(long max, scala.Function1<Out,S> seed, scala.Function2<S,Out,S> aggregate)`
`static <S> FlowOps`	`batchWeighted(long max, scala.Function1<Out,java.lang.Object> costFn, scala.Function1<Out,S> seed, scala.Function2<S,Out,S> aggregate)`
`static FlowOps`	`buffer(int size, OverflowStrategy overflowStrategy)`
`static <T> FlowOps`	`collect(scala.PartialFunction<Out,T> pf)`
`static FlowOps`	`completionTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static <U,Mat2> FlowOps`	`concat(Graph<SourceShape<U>,Mat2> that)`
`protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2>`	`concatGraph(Graph<SourceShape<U>,Mat2> that)`
`static <U,Mat2,Mat3> FlowOpsMat`	`concatMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <O2> FlowOps`	`conflate(scala.Function2<O2,O2,O2> aggregate)`
`static <S> FlowOps`	`conflateWithSeed(scala.Function1<Out,S> seed, scala.Function2<S,Out,S> aggregate)`
`static FlowOps`	`delay(scala.concurrent.duration.FiniteDuration of, DelayOverflowStrategy strategy)`
`static DelayOverflowStrategy`	`delay$default$2()`
`static FlowOps`	`detach()`
`static FlowOps`	`drop(long n)`
`static FlowOps`	`dropWhile(scala.Function1<Out,java.lang.Object> p)`
`static FlowOps`	`dropWithin(scala.concurrent.duration.FiniteDuration d)`
`static <U> FlowOps`	`expand(scala.Function1<Out,scala.collection.Iterator<U>> extrapolate)`
`static FlowOps`	`filter(scala.Function1<Out,java.lang.Object> p)`
`static FlowOps`	`filterNot(scala.Function1<Out,java.lang.Object> p)`
`static <T,M> FlowOps`	`flatMapConcat(scala.Function1<Out,Graph<SourceShape<T>,M>> f)`
`static <T,M> FlowOps`	`flatMapMerge(int breadth, scala.Function1<Out,Graph<SourceShape<T>,M>> f)`
`static <T> FlowOps`	`fold(T zero, scala.Function2<T,Out,T> f)`
`static <T> FlowOps`	`foldAsync(T zero, scala.Function2<T,Out,scala.concurrent.Future<T>> f)`
`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.
`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.
`static <I,O> Flow<I,O,NotUsed>`	`fromProcessor(scala.Function0<org.reactivestreams.Processor<I,O>> processorFactory)` Creates a Flow from a Reactive Streams `Processor`
`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.
`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.
`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.
`static <K> SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`groupBy(int maxSubstreams, scala.Function1<Out,K> f)`
`static FlowOps`	`grouped(int n)`
`static FlowOps`	`groupedWithin(int n, scala.concurrent.duration.FiniteDuration d)`
`static FlowOps`	`idleTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static FlowOps`	`initialDelay(scala.concurrent.duration.FiniteDuration delay)`
`static FlowOps`	`initialTimeout(scala.concurrent.duration.FiniteDuration timeout)`
`static <U> FlowOps`	`interleave(Graph<SourceShape<U>,?> that, int segmentSize)`
`protected static <U,M> Graph<FlowShape<Out,U>,M>`	`interleaveGraph(Graph<SourceShape<U>,M> that, int segmentSize)`
`static <U,Mat2,Mat3> FlowOpsMat`	`interleaveMat(Graph<SourceShape<U>,Mat2> that, int request, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> FlowOps`	`intersperse(T inject)`
`static <T> FlowOps`	`intersperse(T start, T inject, T end)`
`boolean`	`isIdentity()`
`<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 “top” of the protocol stack:
`<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`.
`<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 “top” of the protocol stack:
`<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`
`static <U> FlowOps`	`keepAlive(scala.concurrent.duration.FiniteDuration maxIdle, scala.Function0<U> injectedElem)`
`static FlowOps`	`limit(long max)`
`static <T> FlowOps`	`limitWeighted(long max, scala.Function1<Out,java.lang.Object> costFn)`
`static FlowOps`	`log(java.lang.String name, scala.Function1<Out,java.lang.Object> extract, LoggingAdapter log)`
`static scala.Function1<Out,java.lang.Object>`	`log$default$2()`
`static LoggingAdapter`	`log$default$3(java.lang.String name, scala.Function1<Out,java.lang.Object> extract)`
`static <T> FlowOps`	`map(scala.Function1<Out,T> f)`
`static <T> FlowOps`	`mapAsync(int parallelism, scala.Function1<Out,scala.concurrent.Future<T>> f)`
`static <T> FlowOps`	`mapAsyncUnordered(int parallelism, scala.Function1<Out,scala.concurrent.Future<T>> f)`
`static <T> FlowOps`	`mapConcat(scala.Function1<Out,scala.collection.immutable.Iterable<T>> f)`
`static FlowOps`	`mapError(scala.PartialFunction<java.lang.Throwable,java.lang.Throwable> pf)`
`<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.
`static <U,M> FlowOps`	`merge(Graph<SourceShape<U>,M> that, boolean eagerComplete)`
`static <U,M> boolean`	`merge$default$2()`
`protected static <U,M> Graph<FlowShape<Out,U>,M>`	`mergeGraph(Graph<SourceShape<U>,M> that, boolean eagerComplete)`
`static <U,Mat2,Mat3> FlowOpsMat`	`mergeMat(Graph<SourceShape<U>,Mat2> that, boolean eagerComplete, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <U,Mat2,Mat3> boolean`	`mergeMat$default$2()`
`static <U,M> FlowOps`	`mergeSorted(Graph<SourceShape<U>,M> that, scala.math.Ordering<U> ord)`
`protected static <U,M> Graph<FlowShape<Out,U>,M>`	`mergeSortedGraph(Graph<SourceShape<U>,M> that, scala.math.Ordering<U> ord)`
`static <U,Mat2,Mat3> FlowOpsMat`	`mergeSortedMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF, scala.math.Ordering<U> ord)`
`StreamLayout.Module`	`module()` INTERNAL API.
`static <Mat2> FlowOpsMat`	`monitor(scala.Function2<Mat,FlowMonitor<Out>,Mat2> combine)`
`Flow<In,Out,Mat>`	`named(java.lang.String name)` Add a name attribute to this Flow.
`static <U,Mat2> FlowOps`	`orElse(Graph<SourceShape<U>,Mat2> secondary)`
`protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2>`	`orElseGraph(Graph<SourceShape<U>,Mat2> secondary)`
`static <U,Mat2,Mat3> FlowOpsMat`	`orElseMat(Graph<SourceShape<U>,Mat2> secondary, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <U> FlowOps`	`prefixAndTail(int n)`
`static <U,Mat2> FlowOps`	`prepend(Graph<SourceShape<U>,Mat2> that)`
`protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2>`	`prependGraph(Graph<SourceShape<U>,Mat2> that)`
`static <U,Mat2,Mat3> FlowOpsMat`	`prependMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <T> FlowOps`	`recover(scala.PartialFunction<java.lang.Throwable,T> pf)`
`static <T> FlowOps`	`recoverWith(scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> pf)`
`static <T> FlowOps`	`recoverWithRetries(int attempts, scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> pf)`
`static <T> FlowOps`	`reduce(scala.Function2<T,T,T> f)`
`<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.
`static <T> FlowOps`	`scan(T zero, scala.Function2<T,Out,T> f)`
`static <T> FlowOps`	`scanAsync(T zero, scala.Function2<T,Out,scala.concurrent.Future<T>> f)`
`FlowShape<In,Out>`	`shape()` The shape of a graph is all that is externally visible: its inlets and outlets.
`static FlowOps`	`sliding(int n, int step)`
`static int`	`sliding$default$2()`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitAfter(scala.Function1<Out,java.lang.Object> p)`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitAfter(SubstreamCancelStrategy substreamCancelStrategy, scala.Function1<Out,java.lang.Object> p)`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitWhen(scala.Function1<Out,java.lang.Object> p)`
`static SubFlow<Out,Mat,FlowOps,java.lang.Object>`	`splitWhen(SubstreamCancelStrategy substreamCancelStrategy, scala.Function1<Out,java.lang.Object> p)`
`static <T> FlowOps`	`statefulMapConcat(scala.Function0<scala.Function1<Out,scala.collection.immutable.Iterable<T>>> f)`
`static FlowOps`	`take(long n)`
`static FlowOps`	`takeWhile(scala.Function1<Out,java.lang.Object> p)`
`static FlowOps`	`takeWhile(scala.Function1<Out,java.lang.Object> p, boolean inclusive)`
`static FlowOps`	`takeWithin(scala.concurrent.duration.FiniteDuration d)`
`static FlowOps`	`throttle(int cost, scala.concurrent.duration.FiniteDuration per, int maximumBurst, scala.Function1<Out,java.lang.Object> costCalculation, ThrottleMode mode)`
`static FlowOps`	`throttle(int elements, scala.concurrent.duration.FiniteDuration per, int maximumBurst, ThrottleMode mode)`
`<Mat2> Sink<In,Mat>`	`to(Graph<SinkShape<Out>,Mat2> sink)` Connect this `Flow` to a `Sink`, concatenating the processing steps of both.
`<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.
`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.
`java.lang.String`	`toString()`
`static <T> FlowOps`	`transform(scala.Function0<Stage<Out,T>> mkStage)`
`static <T,M> FlowOpsMat`	`transformMaterializing(scala.Function0<scala.Tuple2<Stage<Out,T>,M>> mkStageAndMaterialized)`
`<T,Mat2> Flow<In,T,Mat>`	`via(Graph<FlowShape<Out,T>,Mat2> flow)`
`<T,Mat2,Mat3> Flow<In,T,Mat3>`	`viaMat(Graph<FlowShape<Out,T>,Mat2> flow, scala.Function2<Mat,Mat2,Mat3> combine)` Transform this `Flow` by appending the given processing steps.
`static <Mat2> FlowOpsMat`	`watchTermination(scala.Function2<Mat,scala.concurrent.Future<Done>,Mat2> matF)`
`Flow<In,Out,Mat>`	`withAttributes(Attributes attr)` Change the attributes of this `Flow` to the given ones and seal the list of attributes.
`static <U> FlowOps`	`zip(Graph<SourceShape<U>,?> that)`
`protected static <U,M> Graph<FlowShape<Out,scala.Tuple2<Out,U>>,M>`	`zipGraph(Graph<SourceShape<U>,M> that)`
`static <U,Mat2,Mat3> FlowOpsMat`	`zipMat(Graph<SourceShape<U>,Mat2> that, scala.Function2<Mat,Mat2,Mat3> matF)`
`static <Out2,Out3> FlowOps`	`zipWith(Graph<SourceShape<Out2>,?> that, scala.Function2<Out,Out2,Out3> combine)`
`protected static <Out2,Out3,M> Graph<FlowShape<Out,Out3>,M>`	`zipWithGraph(Graph<SourceShape<Out2>,M> that, scala.Function2<Out,Out2,Out3> combine)`
`static FlowOps`	`zipWithIndex()`
`static <Out2,Out3,Mat2,Mat3> FlowOpsMat`	`zipWithMat(Graph<SourceShape<Out2>,Mat2> that, scala.Function2<Out,Out2,Out3> combine, scala.Function2<Mat,Mat2,Mat3> matF)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface akka.stream.scaladsl.FlowOpsMat
alsoToMat, concatMat, interleaveMat, mergeMat, mergeSortedMat, monitor, orElseMat, prependMat, transformMaterializing, watchTermination, zipMat, zipWithMat

Methods inherited from interface akka.stream.scaladsl.FlowOps
alsoTo, alsoToGraph, andThen, backpressureTimeout, batch, batchWeighted, buffer, collect, completionTimeout, concat, concatGraph, conflate, conflateWithSeed, delay, detach, drop, dropWhile, dropWithin, expand, filter, filterNot, flatMapConcat, flatMapMerge, fold, foldAsync, groupBy, grouped, groupedWithin, idleTimeout, initialDelay, initialTimeout, interleave, interleaveGraph, intersperse, intersperse, keepAlive, limit, limitWeighted, log, map, mapAsync, mapAsyncUnordered, mapConcat, mapError, merge, mergeGraph, mergeSorted, mergeSortedGraph, orElse, orElseGraph, prefixAndTail, prepend, prependGraph, recover, recoverWith, recoverWithRetries, reduce, scan, scanAsync, sliding, splitAfter, splitAfter, splitWhen, splitWhen, statefulMapConcat, take, takeWhile, takeWhile, takeWithin, throttle, throttle, transform, zip, zipGraph, zipWith, zipWithGraph, zipWithIndex

Constructor Detail

Flow

public Flow(StreamLayout.Module module)

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.

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

recover

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

recoverWith

public static <T> FlowOps recoverWith(scala.PartialFunction<java.lang.Throwable,Graph<SourceShape<T>,NotUsed>> 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)

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)

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)

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)

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)

delay

public static FlowOps delay(scala.concurrent.duration.FiniteDuration of,
                            DelayOverflowStrategy strategy)

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

buffer

public static FlowOps buffer(int size,
                             OverflowStrategy overflowStrategy)

transform

public static <T> FlowOps transform(scala.Function0<Stage<Out,T>> mkStage)

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)

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,
                               int maximumBurst,
                               ThrottleMode mode)

throttle

public static FlowOps throttle(int cost,
                               scala.concurrent.duration.FiniteDuration per,
                               int maximumBurst,
                               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)

zip

public static <U> FlowOps zip(Graph<SourceShape<U>,?> that)

zipGraph

protected static <U,M> Graph<FlowShape<Out,scala.Tuple2<Out,U>>,M> zipGraph(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)

zipWithIndex
```
public static FlowOps zipWithIndex()
```

interleave

public static <U> FlowOps interleave(Graph<SourceShape<U>,?> that,
                                     int segmentSize)

interleaveGraph

protected static <U,M> Graph<FlowShape<Out,U>,M> interleaveGraph(Graph<SourceShape<U>,M> that,
                                                                 int segmentSize)

merge

public static <U,M> FlowOps merge(Graph<SourceShape<U>,M> that,
                                  boolean eagerComplete)

mergeGraph

protected static <U,M> Graph<FlowShape<Out,U>,M> mergeGraph(Graph<SourceShape<U>,M> that,
                                                            boolean eagerComplete)

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)

concat

public static <U,Mat2> FlowOps concat(Graph<SourceShape<U>,Mat2> that)

concatGraph

protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2> concatGraph(Graph<SourceShape<U>,Mat2> that)

prepend

public static <U,Mat2> FlowOps prepend(Graph<SourceShape<U>,Mat2> that)

prependGraph

protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2> prependGraph(Graph<SourceShape<U>,Mat2> that)

orElse

public static <U,Mat2> FlowOps orElse(Graph<SourceShape<U>,Mat2> secondary)

orElseGraph

protected static <U,Mat2> Graph<FlowShape<Out,U>,Mat2> orElseGraph(Graph<SourceShape<U>,Mat2> secondary)

$plus$plus

public static <U,M> FlowOps $plus$plus(Graph<SourceShape<U>,M> that)

alsoTo

public static FlowOps alsoTo(Graph<SinkShape<Out>,?> that)

alsoToGraph

protected static <M> Graph<FlowShape<Out,Out>,M> alsoToGraph(Graph<SinkShape<Out>,M> that)

andThen

public static <T> FlowOps andThen(Stages.SymbolicStage<Out,T> op)

sliding$default$2
```
public static int sliding$default$2()
```

delay$default$2

public static DelayOverflowStrategy delay$default$2()

merge$default$2

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

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)

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)

mergeMat

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

interleaveMat

public static <U,Mat2,Mat3> FlowOpsMat interleaveMat(Graph<SourceShape<U>,Mat2> that,
                                                     int request,
                                                     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)

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)

transformMaterializing

public static <T,M> FlowOpsMat transformMaterializing(scala.Function0<scala.Tuple2<Stage<Out,T>,M>> mkStageAndMaterialized)

mergeMat$default$2

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

module
```
public StreamLayout.Module module()
```
Description copied from interface: Graph

INTERNAL API.
Every materializable element must be backed by a stream layout module

Specified by:

module in interface Graph<FlowShape<In,Out>,Mat>

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<FlowShape<In,Out>,Mat>

Returns:

(undocumented)

toString
```
public java.lang.String toString()
```
Overrides:

toString in class java.lang.Object

isIdentity
```
public boolean isIdentity()
```

via

public <T,Mat2> Flow<In,T,Mat> via(Graph<FlowShape<Out,T>,Mat2> flow)

Specified by:: via in interface FlowOps<Out,Mat>

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 ~~> | this | ~Out~> | flow | ~~> T
     |  |      |        |      |  |
     |  +------+        +------+  |
     +----------------------------+
 
```
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<Out,Mat>

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 ~~> | flow | ~Out~> | sink |  |
     |  |      |        |      |  |
     |  +------+        +------+  |
     +----------------------------+

The materialized value of the combined Sink will be the materialized value of the current flow (ignoring the given Sink’s value), use toMat if a different strategy is needed.

Specified by:: to in interface FlowOps<Out,Mat>
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 ~~> | flow | ~Out~> | sink |  |
     |  |      |        |      |  |
     |  +------+        +------+  |
     +----------------------------+
 
```
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<Out,Mat>

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<Out,Mat>

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’s value), use 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 “top” 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’s value), use 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 “top” 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)
```
Change the attributes of this Flow to the given ones and seal the list of attributes. This means that further calls will not be able to remove these attributes, but instead add new ones. Note that this operation has no effect on an empty Flow (because the attributes apply only to the contained processing stages).

Specified by:

withAttributes in interface Graph<FlowShape<In,Out>,Mat>

Specified by:

withAttributes in interface FlowOps<Out,Mat>

Parameters:

attr - (undocumented)

Returns:

(undocumented)

addAttributes
```
public Flow<In,Out,Mat> addAttributes(Attributes attr)
```
Add the given attributes to this Flow. Further calls to withAttributes will not remove these attributes. Note that this operation has no effect on an empty Flow (because the attributes apply only to the contained processing stages).

Specified by:

addAttributes in interface Graph<FlowShape<In,Out>,Mat>

Specified by:

addAttributes in interface FlowOps<Out,Mat>

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 Graph<FlowShape<In,Out>,Mat>

Specified by:

named in interface FlowOps<Out,Mat>

Parameters:

name - (undocumented)

Returns:

(undocumented)

async
```
public Flow<In,Out,Mat> async()
```
Put an asynchronous boundary around this Flow

Specified by:

async in interface Graph<FlowShape<In,Out>,Mat>

Specified by:

async in interface FlowOps<Out,Mat>

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 Flow<In,Out,Mat> asJava()
```
Converts this Scala DSL element to it's Java DSL counterpart.

Class Flow<In,Out,Mat>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface akka.stream.scaladsl.FlowOpsMat

Methods inherited from interface akka.stream.scaladsl.FlowOps

Constructor Detail

Flow

Method Detail

fromProcessor

fromProcessorMat

apply

fromFunction

fromGraph

fromSinkAndSource

fromSinkAndSourceMat

recover

recoverWith

recoverWithRetries

mapError

map

mapConcat

statefulMapConcat

mapAsync

mapAsyncUnordered

filter

filterNot

takeWhile

takeWhile

dropWhile

collect

grouped

limit

limitWeighted

sliding

scan

scanAsync

fold

foldAsync

reduce

intersperse

intersperse

groupedWithin

delay

drop

dropWithin

take

takeWithin

conflateWithSeed

conflate

batch

batchWeighted

expand

buffer

transform

prefixAndTail

groupBy

splitWhen

splitWhen

splitAfter

splitAfter

flatMapConcat

flatMapMerge

initialTimeout

completionTimeout

idleTimeout

backpressureTimeout

keepAlive

throttle

throttle

detach

initialDelay

log

zip

zipGraph

zipWith

zipWithGraph

zipWithIndex

interleave

interleaveGraph